refactor(#2897): carry the meta-update inputs on the MetaLock node

Second of the `Dag` field removals, and the same shape as the first:
`DagSpec`/`NodeKind::Dag` carried an `inputs: Vec<String>` that exactly
one node ever read. Both reads live inside `run_meta_lock` — the
`meta::lock_update` call and the `meta_update_cascade_agents` fan-out —
so the list now rides `NodeKind::MetaLock` itself.

The executor stops touching `Claim` for this node entirely: its dispatch
arm already destructured `MetaLock { sweep, fanout }`, so `inputs` joins
them and the `claim` parameter, which had no other use, is gone.

Falls out of that:
- `Claim::inputs` and `DagMeta::inputs` delete.
- `dag_view`'s DAG-level projection onto the `MetaLock` node reads the
  payload instead. The wire `NodeView::inputs` is unchanged: still
  populated on the `meta_lock` node alone.
- the boot sweep names no inputs (it bumps `hyperhive` alone via
  `lock_update_hyperhive`), which the construction site now says out loud
  rather than leaving implicit in an empty DAG-level field.

Checked with clippy (`--all-targets -D warnings`), `cargo test -p
hive-c0re` (320 passed) and `nix fmt`. No option surface is touched, so
no nix-eval gate.

hive-c0re/src/job_queue/exec.rs

@@ -80,9 +80,11 @@ pub(super) async fn run_node(coord: &Arc<Coordinator>, claim: &Claim) -> Result<
         NodeKind::PostSwap { .. } => run_post_swap(coord, claim).await,
         NodeKind::Provision { .. } => run_provision(coord, claim).await,
         NodeKind::Create { .. } => run_create(claim).await,
-        NodeKind::MetaLock { sweep, fanout } => {
-            run_meta_lock(coord, claim, *sweep, fanout.clone()).await
-        }
+        NodeKind::MetaLock {
+            sweep,
+            fanout,
+            inputs,
+        } => run_meta_lock(coord, *sweep, fanout.clone(), inputs).await,
         NodeKind::Reconcile { .. } => run_reconcile(coord, claim).await,
         NodeKind::Start { .. } => run_start(coord, claim).await,
         NodeKind::Stop { .. } => run_stop(coord, claim).await,
@@ -318,9 +320,9 @@ async fn run_create(claim: &Claim) -> Result<NodeOutput> {
 /// flavour propagates errors, and a failed bump fans out nothing.
 async fn run_meta_lock(
     coord: &Arc<Coordinator>,
-    claim: &Claim,
     sweep: bool,
     fanout: Option<Vec<String>>,
+    inputs: &[String],
 ) -> Result<NodeOutput> {
     if sweep {
         if let Err(e) = crate::meta::lock_update_hyperhive().await {
@@ -353,12 +355,12 @@ async fn run_meta_lock(
         return Ok(NodeOutput { append_subgraph });
     }
     let _progress = coord.meta_update_guard();
-    crate::meta::lock_update(&claim.inputs).await?;
+    crate::meta::lock_update(inputs).await?;
     // Lock file changed — meta-inputs panel re-renders.
     crate::dashboard::emit_meta_inputs_snapshot(coord);
     let cascade = match fanout {
         Some(list) => list,
-        None => meta_update_cascade_agents(&claim.inputs).await,
+        None => meta_update_cascade_agents(inputs).await,
     };
     // Grow one rebuild subgraph per affected agent into *this* meta-update
     // DAG (rooted on this `MetaLock`, so they build against the post-bump