jobq: the core alias is a JobBuilder, not a Job

A JobBuilder holds pending nodes that are not in the graph yet — it is
the thing you declare into. Naming the alias Job claimed it was the work
itself, and the name propagated into every parameter derived from it
(job: super::Job in run_node read as if it carried the DAG).

Prose uses meaning the job *queue* are left alone: main.rs's "Job-queue
scheduler" comment and the docs/coordinator.md reference.

315 tests pass unchanged.

hive-c0re/src/job_queue/submit.rs

@@ -6,7 +6,7 @@
 //! state, which needs an async `lifecycle::is_running` read that a pure/sync
 //! template can't do. So these fns are async — they read each agent's state,
 //! assemble a per-agent subgraph out of the shared pure primitives
-//! (`Job::node` + `templates::rebuild_nodes`), all declaring into ONE job
+//! (`JobBuilder::node` + `templates::rebuild_nodes`), all declaring into ONE job
 //! (independent per-agent roots, concurrent on their own leases).
 //!
 //! Dynamic shape rule: `stop`/`start` carry a head `SetWanted(w)` (durable
@@ -27,7 +27,7 @@ use std::sync::Arc;
 use super::model::NodeKind;
 use super::resource::Resource;
 use super::templates::rebuild_nodes;
-use super::{Job, Source, templates};
+use super::{JobBuilder, Source, templates};
 use crate::coordinator::Coordinator;
 use crate::lifecycle;
 
@@ -35,7 +35,7 @@ fn submit_and_emit(
     coord: &Arc<Coordinator>,
     source: Source,
     reason: String,
-    declare: impl FnOnce(&Job),
+    declare: impl FnOnce(&JobBuilder),
 ) -> u64 {
     let id = coord
         .job_queue
@@ -67,7 +67,7 @@ pub fn rebuild(coord: &Arc<Coordinator>, agent: &str, source: Source, reason: St
 /// actually running (nothing to drain on a down container). The `Reconcile`
 /// stays even for a down agent so a race-up between the state read and exec
 /// is still stopped in-DAG.
-fn stop_chain(b: &Job, agent: &str, graceful: bool, running: bool) {
+fn stop_chain(b: &JobBuilder, agent: &str, graceful: bool, running: bool) {
     // `SetWanted` is the group root and owns the agent lease; the mechanical
     // steps are its children (borrow the lease, run once it reaches `Finishing`,
     // dep-ordered among themselves).
@@ -107,7 +107,7 @@ fn stop_chain(b: &Job, agent: &str, graceful: bool, running: bool) {
 /// agent gets the rebuild subgraph (its tail `Reconcile` starts it on
 /// current derivations), otherwise a plain `Reconcile` (which starts a down
 /// agent and noops an already-running one).
-fn start_chain(b: &Job, agent: &str, running: bool, stale: bool) {
+fn start_chain(b: &JobBuilder, agent: &str, running: bool, stale: bool) {
     let wanted = b
         .node(NodeKind::SetWanted {
             agent: agent.to_owned(),
@@ -138,7 +138,7 @@ fn start_chain(b: &Job, agent: &str, running: bool, stale: bool) {
 /// before `Reconcile`; a down agent gets just `Reconcile`, which
 /// converges to intent — a stopped (`wanted = Off`) agent stays stopped,
 /// a crashed (`wanted = Up`) agent comes back up.
-fn restart_chain(b: &Job, agent: &str, graceful: bool, running: bool) {
+fn restart_chain(b: &JobBuilder, agent: &str, graceful: bool, running: bool) {
     let a = || agent.to_owned();
     if !running {
         // Nothing to bounce — a lone Reconcile converges to intent.
@@ -198,7 +198,7 @@ fn restart_chain(b: &Job, agent: &str, graceful: bool, running: bool) {
 // subgraph's indices onto another's used to be a function.
 
 /// Declare the stop DAG from explicit `(agent, running)` targets.
-pub(crate) fn stop_nodes(b: &Job, targets: &[(String, bool)], graceful: bool) {
+pub(crate) fn stop_nodes(b: &JobBuilder, targets: &[(String, bool)], graceful: bool) {
     for (agent, running) in targets {
         stop_chain(b, agent, graceful, *running);
     }
@@ -210,14 +210,14 @@ pub(crate) fn stop_nodes(b: &Job, targets: &[(String, bool)], graceful: bool) {
 /// running under its lease, so a down+stale agent that grew a rebuild subgraph
 /// reports `rebuilding` during its swap and `starting` at its reconcile,
 /// without the DAG having to guess one label covering every target.
-pub(crate) fn start_nodes(b: &Job, targets: &[(String, bool, bool)]) {
+pub(crate) fn start_nodes(b: &JobBuilder, targets: &[(String, bool, bool)]) {
     for (agent, running, stale) in targets {
         start_chain(b, agent, *running, *stale);
     }
 }
 
 /// Declare the restart DAG from explicit `(agent, running)` targets.
-pub(crate) fn restart_nodes(b: &Job, targets: &[(String, bool)], graceful: bool) {
+pub(crate) fn restart_nodes(b: &JobBuilder, targets: &[(String, bool)], graceful: bool) {
     for (agent, running) in targets {
         restart_chain(b, agent, graceful, *running);
     }