refactor(#2949): kill Declare — a running node declares onto its own builder

A node no longer hands back a recipe for the scheduler to replay later. It
declares straight onto a builder it was given, and that builder is inserted
as part of completing the node.

Deleted: `pub type Declare`, `struct NodeOutput` (+ its hand-written `Debug`),
`JobQueue::append_subgraph`. Nothing added to `Dag` / `DagView`.

jobq gains `Scheduler::new_job()` (the only way to obtain a `JobBuilder`) and
`complete_growing(id, outcome, grown)`, which inserts under `id` and *then*
completes it, so a DAG cannot roll terminal while grown work is still pending.
`complete()` and `complete_growing()` share a private `finish()` rather than
one redirecting through the other. The DAG-gone guard lives beside the graph
now, where it cannot be skipped, instead of being a caller-side lookup.

The growth executors return data (`run_meta_lock -> (Vec<String>, RebuildOpts)`,
`run_reconcile -> Option<NodeKind>`) rather than taking the builder: a `&Job`
parameter is live for the whole function body, and `&RefCell<T>` is never
`Send`, so an async fn taking one cannot be spawned. `run_node` threads the
builder by value and hands it back.

A node can now declare work and then fail, which was previously inexpressible.
`grown` is dropped in that case — failure cancel-cascades downstream, so
inserting it would only add nodes to immediately cancel — and the log line
carries `grown_nodes` so the drop is visible.

hive-c0re/src/job_queue/model.rs

@@ -407,9 +407,9 @@ impl NodeKind {
 /// Generic over the recipe rather than boxing it: a spec goes from the template
 /// that returns it straight to the `submit` that consumes it, so the closure's
 /// concrete type is known the whole way and needs neither an allocation nor a
-/// `Send` bound. (The executor's `append_subgraph` is the case that *does* need
-/// a boxed [`super::Declare`] — its recipes are collected into a `Vec` and
-/// applied later, across a task boundary.)
+/// `Send` bound. Nothing boxes a recipe any more — a running node grows its DAG
+/// by declaring straight onto the builder it was handed, so there is no recipe
+/// to store and replay across a task boundary.
 pub struct DagSpec<F> {
     pub source: Source,
     /// Free-form "why".