feat(runner, cli, research): metric/tap schema carriers + the C29 coverage walk

C29 compile/unit seam, tasks 6-10 -- iteration 1 of the self-description
plan complete: every engine-shipped vocabulary entry now carries a
gate-clean one-line meaning.

- aura-runner: the internal tap recording sink threads its doc (the
  last unthreaded NodeSchema site) -- first full workspace build since
  the field became required.
- aura-cli scaffold: the sample node's template carries a doc line plus
  a maintenance comment, so every scaffolded extension crate starts
  gate-clean; both extension-vocabulary fixture exemplars thread real
  meaning lines (the load seam walks these in iteration 2). New E2E:
  the scaffold's own doc must pass its own gate -- an alibi doc in the
  template would teach the wrong pattern to every new project, and the
  compiler checks only the field's presence, never its shape.
- aura-research: metric_vocabulary()/tap_vocabulary() promote from bare
  name arrays to MetricSchema/TapSchema carriers (id + doc, 17 + 4
  authored lines); callers adapt to .id with byte-identical output
  (introspection goldens unchanged). The #190 guard keeps its triple --
  the doc column adds no fourth roster site.
- Coverage: tests/self_description.rs walks all five vocabularies
  (blocks, metrics, taps, folds, std nodes) through doc_gate -- the
  guard that keeps any future edit from blanking a doc.

Adjudicated review residue: the 17 metric doc strings are surfaced by
no CLI path yet -- deliberate; task 8 pins callers byte-identical, the
surfacing belongs to the CLI self-description work (#315). Plan-cited
coordinates lib.rs:1003/:1283 resolved to the real caller sites
(:1019/:1299); the plan's literal test code was reconciled to the real
accessors (FoldRegistry::core().roster(), Env::std()).

Gates: cargo test --workspace green (0 failed, incl. the new coverage
walk + scaffold E2E); cargo clippy --workspace --all-targets --
-D warnings clean.

refs #316

crates/aura-cli/tests/fixtures/demo-project/src/lib.rs

@@ -26,6 +26,7 @@ impl Identity {
                 }],
                 output: vec![FieldSpec { name: "value".into(), kind: ScalarKind::F64 }],
                 params: vec![],
+                doc: "one-input f64 pass-through",
             },
             |_| Box::new(Identity::new()),
         )

crates/aura-cli/tests/fixtures/nested-nodes-project/nodecrate/src/lib.rs

@@ -29,6 +29,7 @@ impl Identity {
                 }],
                 output: vec![FieldSpec { name: "value".into(), kind: ScalarKind::F64 }],
                 params: vec![],
+                doc: "one-input f64 pass-through",
             },
             |_| Box::new(Identity::new()),
         )

crates/aura-cli/tests/project_nodes.rs

@@ -211,3 +211,33 @@ fn attached_crate_namespace_resolves_after_build() {
         "{}", String::from_utf8_lossy(&out.stdout)
     );
 }
+
+/// Property (#316 self-description): the scaffold's own seed node ships a
+/// `doc:` line that itself passes the C29 shape gate (`aura_core::doc_gate`)
+/// — non-empty and not a bare restatement of the type name. This exact text
+/// is what a new extension author copy-pastes as the very first node of
+/// their crate; if the scaffold's own doc failed the gate it would teach the
+/// wrong pattern (an alibi doc) to every project built from it, and nothing
+/// else would catch that — `NodeSchema.doc` is required at compile time
+/// (E0063 without it) but its *shape* is never checked by the compiler.
+#[test]
+fn nodes_new_scaffold_doc_passes_the_doc_gate() {
+    let cwd = temp_cwd("doc-gate");
+    assert!(aura(&["new", "lab"], &cwd).status.success());
+    let proj = cwd.join("lab");
+    let engine = env!("CARGO_MANIFEST_DIR").to_string() + "/../..";
+    assert!(aura(&["nodes", "new", "lab-nodes", "--engine-path", &engine], &proj).status.success());
+    let lib = std::fs::read_to_string(cwd.join("lab-nodes/src/lib.rs")).unwrap();
+    let doc_line = lib
+        .lines()
+        .find(|l| l.trim_start().starts_with("doc:"))
+        .unwrap_or_else(|| panic!("scaffold must carry a doc: field: {lib}"));
+    let doc_text = doc_line
+        .split_once('"')
+        .and_then(|(_, rest)| rest.rsplit_once('"'))
+        .map(|(text, _)| text)
+        .unwrap_or_else(|| panic!("doc: field must be a string literal: {doc_line}"));
+    aura_core::doc_gate("lab_nodes::Scale", doc_text).unwrap_or_else(|f| {
+        panic!("scaffold's own doc line fails its own gate: {f:?} — {doc_text:?}")
+    });
+}

crates/aura-cli/tests/self_description.rs

@@ -0,0 +1,43 @@
+//! C29 coverage: every engine-shipped vocabulary entry carries a
+//! gate-passing one-line meaning. Blocks, metrics, tap slots, folds, and
+//! the std node vocabulary — the compile/unit seam of the self-description
+//! contract.
+
+use aura_core::doc_gate;
+
+#[test]
+fn every_shipped_vocabulary_entry_passes_the_doc_gate() {
+    // process + campaign blocks (BlockSchema.doc — the pre-existing model)
+    for b in aura_research::process_vocabulary()
+        .iter()
+        .chain(aura_research::campaign_vocabulary().iter())
+    {
+        doc_gate(b.id, b.doc)
+            .unwrap_or_else(|f| panic!("block {}: {:?}", b.id, f));
+    }
+    // metrics
+    for m in aura_research::metric_vocabulary() {
+        doc_gate(m.id, m.doc)
+            .unwrap_or_else(|f| panic!("metric {}: {:?}", m.id, f));
+    }
+    // tap slots
+    for t in aura_research::tap_vocabulary() {
+        doc_gate(t.id, t.doc)
+            .unwrap_or_else(|f| panic!("tap {}: {:?}", t.id, f));
+    }
+    // tap folds (the #283 registry roster already carries docs)
+    for (name, doc) in aura_runner::tap_plan::FoldRegistry::core().roster() {
+        doc_gate(name, doc)
+            .unwrap_or_else(|f| panic!("fold {}: {:?}", name, f));
+    }
+    // std node vocabulary: resolve each shipped type id to its schema
+    let env = aura_runner::project::Env::std();
+    for &type_id in aura_vocabulary::std_vocabulary_types() {
+        let builder = env
+            .resolve(type_id)
+            .unwrap_or_else(|| panic!("std type {type_id} must resolve"));
+        let schema = builder.schema();
+        doc_gate(type_id, schema.doc)
+            .unwrap_or_else(|f| panic!("node {type_id}: {:?}", f));
+    }
+}