feat(#2450): collapse the startup sweep into one inline DAG

The boot is now ONE DAG, assembled inline in submit_boot_tree — no boot_root
Noop anchor, no per-agent child DAGs, no display-only parent_id grouping: a
sweep MetaLock root (only when something is stale) that grows one rebuild
subgraph per stale agent into the same DAG (via append_subgraph, previous
commit), plus one Reconcile root per drifted agent (independent — a boot
reconcile needs no lock bump).

- submit_boot_tree builds the DagSpec inline; removed the single-use
  templates::{boot_root, startup_sweep} builders (inlined per the operator's
  "don't force single-use shapes into templates.rs" steer).
- fanout_specs simplified to the meta-update cascade path only — the startup
  sweep no longer fans out child DAGs, so its branch was dead.
- test: append_subgraph_roots_on_emitter_and_rebases_local_deps.

Vestigial after this (deliberately left as follow-ups, flagged in the PR):
NodeKind::Noop is now unconstructed (contained to hive-c0re, removable);
Template::StartupSweep is unconstructed but a hive-sh4re wire type
(frontend-coordinated removal).

hive-c0re/src/job_queue/tests.rs

@@ -450,6 +450,58 @@ fn offline_agents_skip_mechanical_nodes_but_keep_reconcile() {
     );
 }
 
+#[test]
+fn append_subgraph_roots_on_emitter_and_rebases_local_deps() {
+    // The startup-sweep mechanism: a `MetaLock` emitter grows one rebuild
+    // subgraph per stale agent into its OWN DAG. Each subgraph is rooted on
+    // the emitter and its LOCAL 0-based deps are rebased onto the DAG.
+    let q = JobQueue::new(4);
+    let spec = DagSpec {
+        template: Template::Boot,
+        source: Source::AutoUpdate,
+        reason: "sweep".to_owned(),
+        parent_id: None,
+        approval_id: None,
+        inputs: Vec::new(),
+        perm_payload: None,
+        transient: None,
+        nodes: vec![NodeSpec {
+            agent: "hyperhive".to_owned(),
+            kind: NodeKind::MetaLock {
+                sweep: true,
+                fanout: None,
+            },
+            deps: Vec::new(),
+        }],
+    };
+    let id = submit(&q, spec);
+    let emitter = claim_one(&q);
+    assert_eq!(emitter.kind.as_str(), "meta_lock");
+    // Two independent per-agent subgraphs — the REAL production shape the
+    // sweep MetaLock grows (`rebuild_nodes(_, true, 0)`: root Prebuild →
+    // StopForUpdate → Swap → Reconcile, local 0-based deps), so this test
+    // tracks any drift in that builder's root-first (`base = 0`) shape.
+    let subgraph = |agent: &str| templates::rebuild_nodes(agent, true, 0);
+    // Must append BEFORE completing the emitter (the documented contract).
+    q.append_subgraph(id, subgraph("a"), emitter.node_id);
+    q.append_subgraph(id, subgraph("b"), emitter.node_id);
+    q.complete_node(id, emitter.node_id, Ok(()));
+    // Still ONE DAG; both subgraph roots become ready once the emitter is
+    // Done (rooted on it), each on its own agent lease.
+    assert_eq!(q.snapshot().len(), 1);
+    let next = q.claim_ready();
+    let mut kinds: Vec<(&str, &str)> = next
+        .iter()
+        .map(|c| (c.agent.as_str(), c.kind.as_str()))
+        .collect();
+    kinds.sort_unstable();
+    assert_eq!(
+        kinds,
+        vec![("a", "prebuild"), ("b", "prebuild")],
+        "both rebuild subgraphs root on the emitter and run concurrently in one DAG"
+    );
+}
+
 // ---- failure: cancel-downstream + AfterAny ----
 
 #[test]