refactor(#2949): the build-log row carries its node id

`QueueInner` was `{ sched, node_rt }`, where `node_rt` held exactly one
datum per node: the `build_logs` row id. It existed because a `hive_jobq`
node payload is immutable after insert while the log row is created when
the build starts — so the link could not ride the node.

Invert it: the log row names its node (`build_logs.node_id`, one migration
in the existing `schema_versions` framework). Same single-home property,
in the direction the type system allows.

`QueueInner` is now just the scheduler. That is the point: the queue holds
no per-node side map, so nothing has to be locked alongside the graph.

Deleted as a consequence, each surfaced by dead-code analysis after the
edit above rather than predicted:

- `NodeRuntime`, `node_rt`, `set_build_log_id`, and `build_log_id_of`
  (which linear-scanned the map to match a wire `u64` against opaque
  `NodeId`s). The lookup is an indexed query now.
- `struct Ctx`, entirely. It carried `coord` + `dag_id` + `node_id` into
  the executors so the build-log callback could reach the queue; without
  the callback, `coord`/`dag_id` were never read and `node_id` was already
  on the `Claim` both executors receive.
- `QueueInner::node_running`, which existed only for `set_build_log_id`'s
  "only while running" guard.
- The `Fn(i64)` callbacks on `prebuild_toplevel` / `swap_update` /
  `priv_run_inner`, replaced by a `node_id: Option<u64>` passed down. The
  id travels one way now instead of being registered back.

`meta.rs`'s `nix_logged` passes `None` deliberately: its callers reach it
from outside the queue as well as inside, and nothing reads the link for
them yet.

`id_for_node` takes `MAX(id)` rather than assuming uniqueness — a retried
node opens a second row and the panel wants the current attempt. The test
moved to where the behaviour lives and covers that, plus survival across
completion and non-collision with node-less rows.

hive-c0re/src/job_queue/exec.rs

@@ -26,25 +26,6 @@ use crate::power::{ReconcileAction, reconcile_action};
 /// N × this timeout.
 pub const GRACEFUL_STOP_TIMEOUT: std::time::Duration = std::time::Duration::from_mins(3);
 
-/// Build-log sink for one claimed node.
-struct Ctx<'a> {
-    coord: &'a Arc<Coordinator>,
-    dag_id: u64,
-    node_id: super::NodeId,
-}
-
-impl Ctx<'_> {
-    fn build_log(&self, log_id: i64) {
-        if self
-            .coord
-            .job_queue
-            .set_build_log_id(self.dag_id, self.node_id, log_id)
-        {
-            self.coord.emit_rebuild_queue_snapshot();
-        }
-    }
-}
-
 /// Run one claimed node to completion. Called from a task the
 /// scheduler spawns per claim; the `Result` (stringified) becomes the
 /// node's terminal state.
@@ -67,19 +48,14 @@ pub(super) async fn run_node(
     job: super::Job,
     claim: &Claim,
 ) -> (super::Job, Result<()>) {
-    let ctx = Ctx {
-        coord,
-        dag_id: claim.dag_id,
-        node_id: claim.node_id,
-    };
     // Every arm is `Result<()>`; the three that grow work declare into `job`
     // *synchronously*, after their own awaits have finished. Borrowing `&job`
     // inside an `.await` would make this future non-`Send` (see above), so the
     // growth executors return what to grow rather than taking the builder.
     let result = match &claim.kind {
         NodeKind::MetaSync { relock, .. } => run_meta_sync(coord, claim, *relock).await,
-        NodeKind::Prebuild { .. } => run_prebuild(claim, &ctx).await,
-        NodeKind::Swap { .. } => run_swap(coord, claim, &ctx).await,
+        NodeKind::Prebuild { .. } => run_prebuild(claim).await,
+        NodeKind::Swap { .. } => run_swap(coord, claim).await,
         NodeKind::PostSwap { .. } => run_post_swap(coord, claim).await,
         NodeKind::Provision { .. } => run_provision(coord, claim).await,
         NodeKind::Create { .. } => run_create(claim).await,
@@ -241,7 +217,7 @@ async fn run_meta_sync(coord: &Arc<Coordinator>, claim: &Claim, relock: bool) ->
 /// container is already down: its only purpose is to shrink the swap's
 /// downtime window, so a stopped agent (no uptime to preserve) doesn't
 /// pay the double eval — `Swap` builds inline instead.
-async fn run_prebuild(claim: &Claim, ctx: &Ctx<'_>) -> Result<()> {
+async fn run_prebuild(claim: &Claim) -> Result<()> {
     let name = &claim.agent;
     // Warm the toplevel build only when the container is up — the whole
     // point of prebuild is to shrink the swap's downtime window. A
@@ -249,8 +225,7 @@ async fn run_prebuild(claim: &Claim, ctx: &Ctx<'_>) -> Result<()> {
     // eval and let the downstream `Swap` build inline.
     if crate::lifecycle::is_running(name).await {
         let flake_ref = format!("{}#{name}", crate::paths::meta_root().display());
-        crate::lifecycle::prebuild_toplevel(name, &flake_ref, &|log_id| ctx.build_log(log_id))
-            .await?;
+        crate::lifecycle::prebuild_toplevel(name, &flake_ref, Some(claim.node_id.get())).await?;
     }
     Ok(())
 }
@@ -260,17 +235,15 @@ async fn run_prebuild(claim: &Claim, ctx: &Ctx<'_>) -> Result<()> {
 /// (rev marker, `Rebuilt` event, forge/matrix sync, kick, rescan).
 /// The recovery-start on failure is NOT here — the DAG's tail
 /// `Reconcile` runs after this node terminal ok *or* fail.
-async fn run_swap(coord: &Arc<Coordinator>, claim: &Claim, ctx: &Ctx<'_>) -> Result<()> {
+async fn run_swap(coord: &Arc<Coordinator>, claim: &Claim) -> Result<()> {
     let name = &claim.agent;
     // Swap runs on an already-existing (stopped) container — runtime dir
     // and listener were created earlier. Pure path accessor suffices.
     let agent_dir = crate::paths::agent_runtime_dir(name);
     let hive = coord.hive_env();
     let paths = Coordinator::agent_paths(name, agent_dir);
-    let result = crate::lifecycle::swap_update(name, &hive, &paths, &|log_id| {
-        ctx.build_log(log_id);
-    })
-    .await;
+    let result =
+        crate::lifecycle::swap_update(name, &hive, &paths, Some(claim.node_id.get())).await;
     // On success the Ok-only bookkeeping tail (rev marker, forge/matrix
     // sync, kick, rescan, snapshot) runs in the sibling `PostSwap` node,
     // which deps `AfterOk(Swap)`. On failure `PostSwap` is cancel-cascaded