feat: node output is a record (composite stream), not a single scalar

Cycle 0005 (BLOCKER #1): a node's output generalizes from one scalar to a record
of K >= 1 named base-scalar columns, with a scalar being the degenerate K = 1
case. A node keeps exactly one output port; its payload is now an ordered bundle
of base columns (a composite stream, C7). This unblocks every multi-column
producer the engine needs next -- OHLCV bars and, later, the C10 position-event
table -- none of which could exist while a node emitted at most one column.
Revises C8, sharpens C7 in the design ledger.

Contract (aura-core):
- `NodeSchema.output: ScalarKind` -> `Vec<FieldSpec>` (FieldSpec = { name:
  &'static str, kind }; the field position is what an Edge binds, the name is
  metadata for later sinks/playground, C18).
- `Node::eval -> Option<Scalar>` -> `-> Option<&[Scalar]>`: a node fills a buffer
  it owns (sized once at construction) and returns a borrowed K-field row; `None`
  still means filter/not-warmed. This is the C7-faithful representation chosen
  with the user: zero per-cycle heap allocation on the forward path (rejected:
  Option<Vec<Scalar>> allocates per fire; an inline fixed [Scalar; N] bakes a
  width cap; engine-owned output columns invert the eval model). Scalar output is
  the degenerate 1-field record -- no separate scalar path.

Field-wise binding (aura-engine):
- `Edge` gains `from_field: usize` -- which producer column this edge forwards.
  Consuming a whole record is N edges; there is no "bind whole record" mechanism.
- bootstrap kind-checks per field (`from.output.get(from_field)` -> BadIndex if
  out of range; `field.kind != slot.kind` -> KindMismatch).
- the run loop copies a producer's returned row into one reused scratch buffer
  (resolving the borrow; no per-cycle alloc once warm) and scatters
  scratch[from_field] into each out-edge slot. `NodeBox.out_len` (set at
  bootstrap) backs a debug_assert on the returned row width. `run` returns
  `Vec<Option<Vec<Scalar>>>` (the observed node's full row per cycle -- a
  materialization-surface alloc, not the inter-node hot path).
- the K fields of one record are co-fresh by construction (one eval, one
  timestamp), so C6 is untouched.

aura-std: Sma/Sub migrate to the 1-field degenerate case (hold a [Scalar; 1]
buffer; behaviour unchanged). Sub drops #[derive(Default)] (Scalar has no Default)
for a manual Default.

Proof (aura-engine tests, +5): an Ohlcv 5-field bundler fed by five
timestamp-aligned barrier sources emits one complete bar per timestamp
(ohlcv_bundles_five_field_record); a downstream Sub binds high(1)-low(2)
field-wise, observed end-to-end + a determinism re-run
(edge_binds_single_field_high_minus_low); a second consumer binds close(3)-open(0)
on the same record (distinct_edges_read_distinct_fields); must-fail:
bootstrap_rejects_from_field_out_of_range (BadIndex),
bootstrap_rejects_per_field_kind_mismatch (a TwoField [f64,i64] producer, the i64
field into an f64 slot). All prior 0003/0004 tests adapted to from_field + the Vec
return, expected vectors unchanged (scalar = 1-field record).

Gates re-run by the orchestrator (not just the agent): cargo build/test
--workspace --all-targets (36: aura-core 19 + aura-std 3 + aura-engine 14, 0
failed) / clippy --workspace --all-targets -D warnings clean; surface-purity grep
(no dyn-Any / Rc / RefCell) clean. Ledger C8/C7 edits verified
(Option<&[Scalar]> present, "one series per node" gone, cycle-0005 realization
note added). The glossary composite/node record-reality pass is the audit-time
follow-up.

closes #1
refs walking-skeleton

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

crates/aura-core/src/node.rs

@@ -1,6 +1,7 @@
 //! The node contract (C8): the interface every node implements. A node declares
 //! its inputs (each with its scalar kind, lookback depth, and firing policy, C6)
-//! and its output kind via `schema`, and computes one cycle's output via `eval`.
+//! and its output record (1..K base columns, C7) via `schema`, and computes one
+//! cycle's row via `eval`.
 //! Tunable params (C12/C19) are deliberately not part of the schema yet — see
 //! spec 0002's "Out of scope".
 
@@ -29,21 +30,33 @@ pub struct InputSpec {
     pub firing: Firing,
 }
 
-/// A node's declared interface: its inputs (in order) and its single output
-/// kind. Built once at wiring, never on the hot path — the `Vec` is fine here.
+/// One declared output column of a node's record: its name (metadata for sinks /
+/// the playground, C18) and its scalar kind. The position of a `FieldSpec` in
+/// `NodeSchema.output` is what an `Edge` binds (`Edge::from_field`); the name is
+/// not load-bearing for wiring.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct FieldSpec {
+    pub name: &'static str,
+    pub kind: ScalarKind,
+}
+
+/// A node's declared interface: its inputs (in order) and its output record — an
+/// ordered list of named base columns; length 1 is a scalar (the degenerate
+/// case). Built once at wiring, never on the hot path — the `Vec`s are fine here.
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct NodeSchema {
     pub inputs: Vec<InputSpec>,
-    pub output: ScalarKind,
+    pub output: Vec<FieldSpec>,
 }
 
-/// The universal composable dataflow unit (C8): at most one output, a producer
-/// or transformer. `schema` declares the interface; `eval` computes one cycle's
-/// output (`None` = filter / not-yet-warmed-up). `&mut self` because a node may
-/// keep its own derived state.
+/// The universal composable dataflow unit (C8): one output port carrying a record
+/// of 1..K base columns, a producer or transformer. `schema` declares the
+/// interface; `eval` computes one cycle's row, returning a borrowed slice into a
+/// buffer the node owns (`None` = filter / not-yet-warmed-up). `&mut self` because
+/// a node may keep its own derived state (and its output buffer).
 pub trait Node {
     fn schema(&self) -> NodeSchema;
-    fn eval(&mut self, ctx: Ctx<'_>) -> Option<Scalar>;
+    fn eval(&mut self, ctx: Ctx<'_>) -> Option<&[Scalar]>;
 }
 
 #[cfg(test)]