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/tests.rs

@@ -122,9 +122,23 @@ impl ClaimReady for JobQueue {
 trait CompleteNode {
     fn complete_node(&self, node_id: NodeId, result: Result<(), String>);
     fn complete_node_growing(&self, node_id: NodeId, result: Result<(), String>, grown: Job);
+    fn new_job(&self) -> Job;
 }
 
 impl CompleteNode for JobQueue {
+    /// Mint a builder to declare growth into.
+    ///
+    /// Test-only for the same reason as the rest of this trait: production
+    /// never mints one, because `claim_next` hands each running node its
+    /// builder and takes it back. That leaves `Scheduler::new_job` with no
+    /// non-test caller either — see the note on that fn.
+    fn new_job(&self) -> Job {
+        self.sched()
+            .lock()
+            .expect("job_queue mutex poisoned")
+            .new_job()
+    }
+
     fn complete_node(&self, node_id: NodeId, result: Result<(), String>) {
         self.sched()
             .lock()