feat(#2476): grow the meta-update cascade in-DAG instead of child DAGs

MetaLock's non-sweep completion now grows one rebuild subgraph per
affected agent into the same DAG (append_subgraph), replacing the
fan-out-child-DAGs + cancel_children dance. Drops NodeOutput.fanout and
scheduler's fanout_specs. meta_update DAG carries Rebuilding transient so
each cascade agent gets crash-watch suppression at Swap (the property the
old child Rebuild DAGs held via their own transient); MetaLock head needs
no lease so the pseudo-agent gets no pill.

append_children/parent_id and child-DAG tests are intentionally left for
the #2453 capstone.

hive-c0re/src/job_queue/tests.rs

@@ -502,6 +502,56 @@ fn append_subgraph_roots_on_emitter_and_rebases_local_deps() {
     );
 }
 
+#[test]
+fn meta_update_carries_rebuilding_transient_and_grows_cascade_in_dag() {
+    // The meta-update `MetaLock` grows one rebuild subgraph per affected
+    // agent into its OWN DAG (via append_subgraph), not child DAGs.
+    // The DAG carries `Rebuilding` so the folded rebuilds keep crash-watch
+    // suppression (the property the old child Rebuild DAGs had via their own
+    // transient).
+    let spec = templates::meta_update(
+        vec!["nixpkgs".to_owned()],
+        Source::Manual,
+        "bump".to_owned(),
+        None,
+    );
+    assert!(
+        matches!(
+            spec.transient,
+            Some(crate::coordinator::TransientKind::Rebuilding)
+        ),
+        "meta-update DAG must carry Rebuilding so cascade rebuilds get suppression"
+    );
+    let q = JobQueue::new(4);
+    let id = submit(&q, spec);
+    let meta_lock = claim_one(&q);
+    assert_eq!(meta_lock.kind.as_str(), "meta_lock");
+    // Simulate the executor growing the cascade in-DAG (`relock = false` — a
+    // cascade child must not re-lock and revert the parent's bump).
+    for agent in ["alice", "bob"] {
+        q.append_subgraph(
+            id,
+            templates::rebuild_nodes(agent, false, 0),
+            meta_lock.node_id,
+        );
+    }
+    q.complete_node(id, meta_lock.node_id, Ok(()));
+    // Still ONE DAG — no child DAGs — and both cascade rebuild subgraphs root
+    // on the MetaLock, 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![("alice", "prebuild"), ("bob", "prebuild")],
+        "cascade rebuilds grow in the meta-update DAG, concurrent per agent"
+    );
+}
+
 // ---- failure: cancel-downstream + AfterAny ----
 
 #[test]