jobq: complete is the completion, and failure grows nothing

Two review findings from the previous round, re-checked against the
actual tree rather than against my notes.

`Scheduler::complete` was still a public wrapper whose entire body was
`self.finish(id, outcome)`. Its docstring argued the split was not a
redirect because both completion forms shared `finish` -- but sharing a
private helper is not a reason for two public names. `finish`'s body now
lives in `complete`, and `complete_growing` calls it. Same sharing, one
name, no redirect.

Growth on a failed node is now dropped by `complete_growing` instead of
by the host loop. Failure cancel-cascades to every pending child of the
completing node, and grown work is inserted as its children, so anything
appended here is Skipped by the next statement -- the insert is not
wrong, it is provably pointless. That is a consequence of this crate's
cascade rule, so this crate should be the one enforcing it; a host that
has to remember it can forget it. Behaviour is unchanged: hive-c0re
already dropped growth before calling, and now no longer has to.

`Scheduler::new_job` is left alone but documented for what it is: the
hole in `JobBuilder::new`'s pub(crate) wall, with no non-test caller
since claim_next mints a builder per running node. Closing it is a venue
question rather than a rename, so it stays for now.

hive-c0re/src/job_queue/scheduler.rs

@@ -101,17 +101,14 @@ pub async fn run_worker(coord: Arc<Coordinator>) {
                             "job_queue: node failed"
                         ),
                     }
-                    let outcome = super::outcome_of(result.map_err(|e| format!("{e:#}")));
-                    // Growth is dropped on failure: a node that declared
-                    // follow-up work and *then* failed does not want it run —
-                    // failure cancel-cascades, so inserting it would only add
-                    // nodes to immediately cancel.
-                    let grown = if matches!(outcome, hive_jobq::scheduler::Outcome::Failed(_)) {
-                        coord.job_queue.new_job()
-                    } else {
-                        grown
-                    };
-                    (grown, outcome)
+                    // Growth on a failed node is dropped by `complete_growing`,
+                    // not here: failure cancel-cascades inside jobq, so that
+                    // rule is the crate's to enforce and this loop does not get
+                    // to forget it.
+                    (
+                        grown,
+                        super::outcome_of(result.map_err(|e| format!("{e:#}"))),
+                    )
                 }
             })
         };