topology: drop the parent field and the hierarchy it fed

`topology.json` was a map of `name -> parent | null`, and that value fed
the whole agent hierarchy: `<parent>` / `<children>` recipient sentinels,
the reparenting API (CLI verb, wire verb, dashboard endpoints, DAG node),
the dashboard tree, the rebuild depth sort, and an unconditional
bind-mount grant giving every agent RW on its direct children's state.

Per the operator's ruling the field goes, and with it all of the above.
The file survives as what remains once the value is gone: the roster of
agent names, which is the set `ManageRootAgent` grants mounts over. It is
now a JSON array; `read` still accepts the old map shape and keeps its
keys, so a hive that upgrades across this does not blank its roster (and
so no capability holder loses its mounts for the length of that window).

Two sites kept their behaviour under a different recipient rather than
losing it. Both addressed `<parent>`, which the broker already resolved to
`operator` for a root agent, and every agent is now what that fallback
called a root:

- the harness's turn-failure / plugin-failure notification
  (`Surface::send_to_parent` -> `send_to_operator`), and
- the send allow-list's always-permitted escape hatch, so an agent with a
  restrictive allow-list still has a way to say it is stuck.

What is NOT preserved, deliberately: an agent with no capability no longer
sees any other agent's dirs. `ManageRootAgent`'s own grant is unchanged --
still every agent in the roster, still state RW + config RO, still no
`harness`.

The dashboard's reparenting control (the M0V3 picker) is deleted with its
CSS. The tree rendering that reads `ContainerView.parent` is left for the
frontend owner -- it degrades to a flat list with the field gone.

hive-c0re/src/workers/auto_update.rs

@@ -250,44 +250,6 @@ fn seed_manager_capabilities() {
     }
 }
 
-/// Sort `names` in-place so parents precede their children in the topology.
-/// Uses BFS from root agents (depth 0). Agents absent from `topo` sort last,
-/// alphabetically within their tier. Stable within each depth tier.
-pub fn topology_sort(
-    names: &mut [String],
-    topo: &std::collections::BTreeMap<String, Option<String>>,
-) {
-    use std::collections::{HashMap, VecDeque};
-    // Build depth map using owned clones so the borrow on `names` is released
-    // before the sort_by mutable borrow.
-    let name_set: Vec<String> = names.to_vec();
-    let mut depth: HashMap<String, usize> = HashMap::new();
-    let mut queue: VecDeque<String> = VecDeque::new();
-    // Seed roots: entries with no parent, or names not present in topo at all.
-    for name in &name_set {
-        if topo.get(name).is_none_or(Option::is_none) {
-            depth.insert(name.clone(), 0);
-            queue.push_back(name.clone());
-        }
-    }
-    // BFS to assign depths to children.
-    while let Some(parent) = queue.pop_front() {
-        let d = depth[&parent] + 1;
-        for name in &name_set {
-            let is_child = topo.get(name).and_then(|p| p.as_deref()) == Some(parent.as_str());
-            if is_child && !depth.contains_key(name) {
-                depth.insert(name.clone(), d);
-                queue.push_back(name.clone());
-            }
-        }
-    }
-    names.sort_by(|a, b| {
-        let da = depth.get(a).copied().unwrap_or(usize::MAX);
-        let db = depth.get(b).copied().unwrap_or(usize::MAX);
-        da.cmp(&db).then(a.cmp(b))
-    });
-}
-
 /// Boot reconcile (see the module doc): classify every agent by rev
 /// freshness + persisted `wanted` intent, submit one `Boot` DAG
 /// (hyperhive lock bump growing an in-DAG rebuild subgraph per stale
@@ -305,16 +267,16 @@ pub async fn run(coord: Arc<Coordinator>) -> Result<()> {
 
     let current_rev = current_flake_rev(&coord.hyperhive_flake);
 
-    // Resolve container names to logical agent names, then sort by
-    // topology depth so parents are always rebuilt before their
-    // children. Root agents (depth 0) go first; agents absent from
-    // the topology file sort last (stable, alphabetical within tier).
+    // Resolve container names to logical agent names, then sort. #4472
+    // removed the parent field this used to depth-sort by; with no
+    // hierarchy left to respect, alphabetical is the whole order — and it
+    // is exactly what the depth sort already produced once every agent
+    // was a root.
     let mut logical_names: Vec<String> = containers
         .iter()
         .filter_map(|c| c.strip_prefix(AGENT_PREFIX).map(str::to_owned))
         .collect();
-    let topo = crate::topology::read();
-    topology_sort(&mut logical_names, &topo);
+    logical_names.sort();
 
     // Classify. `get_or_seed` doubles as the one-time migration: an
     // agent without an `agent_power` row is seeded from its observed
@@ -374,8 +336,8 @@ pub async fn run(coord: Arc<Coordinator>) -> Result<()> {
     // Rebuild running agents first. All fanout entries are wanted=Up;
     // among them, warm the live/serving agents onto the fresh config before the
     // stopped-but-wanted-up ones so the scarce build slots hit uptime-critical
-    // agents first. Stable sort keeps topology order (parents before children)
-    // within each running/stopped group. The `drifted` reconciles aren't sorted
+    // agents first. Stable sort keeps the alphabetical order within each
+    // running/stopped group. The `drifted` reconciles aren't sorted
     // — they hold no build slot and run concurrently, so their order is moot.
     fanout.sort_by_key(|(_, running)| !running);
     let fanout: Vec<String> = fanout.into_iter().map(|(name, _)| name).collect();