refactor(aura-engine): Cell into the construction path — param-plane base/frontend split

Cell becomes the carrier of the construction path; Scalar narrows to the author/render boundaries. The validated/enumerated param point carries no redundant kind (it lives once, in the declared param-space); at the author edge the kind is a checksum — two independent sources, the typed value vs. the slot — so the self-describing Scalar stays there. The name->slot binding is dynamic (C23), so the check is necessarily a runtime one and the value must self-describe for it.

Base/frontend split (the AnyColumn push/push_cell pattern one level up): compile_with_cells / bootstrap_with_cells are the kind-check-free base; compile_with_params / bootstrap_with_params are the frontend that adds only the per-value kind checksum, strips to cells (new Scalar::cell(), the partner of Scalar::from_cell), and delegates. lower_items loses its per-primitive kind-check; PrimitiveBuilder::build and the std node builders (sma/ema/exposure/lincomb) read cells.

Boundary: construction -> Cell (PrimitiveBuilder::build, lower_items, GridSpace.axes/points, SweepPoint.params, the sweep closure). Author edges stay Scalar (GridSpace::new, bind, compile_with_params/bootstrap_with_params). walkforward chosen_params stays a self-describing Scalar report record (Option A — WalkForwardResult carries no space); the cell winner is reconstructed once at the WindowRun site via from_cell.

injective-check moved ahead of the arity-check in the frontend to preserve the pre-split error order (DuplicateParamPath before ParamArity). The lossy i64->f64 param projection (scalar_as_f64 / scalar_as_param_f64) is deliberately untouched — a separate follow-up.

Behaviour-preserving (C1): build --all-targets / test / clippy -D warnings / doc all clean across the workspace.

crates/aura-cli/src/main.rs

@@ -13,7 +13,7 @@
 
 mod render;
 
-use aura_core::{zip_params, Firing, Scalar, ScalarKind, Timestamp};
+use aura_core::{zip_params, Cell, Firing, Scalar, ScalarKind, Timestamp};
 use aura_engine::{
     f64_field, monte_carlo, param_stability, summarize, walk_forward, window_of, Composite, Edge,
     FlatGraph, GraphBuilder, Harness, McAggregate, McFamily, RollMode, RunManifest, RunReport,
@@ -378,7 +378,7 @@ fn sweep_family() -> SweepFamily {
         .sweep(|point| {
             let (bp, rx_eq, rx_ex) = sample_blueprint_with_sinks();
             let mut h = bp
-                .bootstrap_with_params(point.to_vec())
+                .bootstrap_with_cells(point)
                 .expect("grid points are kind-checked against param_space");
             let sources: Vec<Box<dyn aura_engine::Source>> =
                 vec![Box::new(VecSource::new(showcase_prices()))];
@@ -470,7 +470,18 @@ fn walkforward_family() -> WalkForwardResult {
         let is_family = sweep_over(w.is.0, w.is.1);
         let best = optimize(&is_family, "total_pips").expect("total_pips is a known metric");
         let (oos_equity, oos_report) = run_oos(&best.params, w.oos.0, w.oos.1);
-        WindowRun { chosen_params: best.params, oos_equity, oos_report }
+        WindowRun {
+            // best.params is the enumerated cell winner; reconstruct the
+            // self-describing report record (Option A) via the in-sample space.
+            chosen_params: best
+                .params
+                .iter()
+                .zip(&is_family.space)
+                .map(|(c, ps)| Scalar::from_cell(ps.kind, *c))
+                .collect(),
+            oos_equity,
+            oos_report,
+        }
     })
 }
 
@@ -490,7 +501,7 @@ fn sweep_over(from: Timestamp, to: Timestamp) -> SweepFamily {
         .sweep(|point| {
             let (bp, rx_eq, rx_ex) = sample_blueprint_with_sinks();
             let mut h = bp
-                .bootstrap_with_params(point.to_vec())
+                .bootstrap_with_cells(point)
                 .expect("grid points are kind-checked against param_space");
             let sources: Vec<Box<dyn aura_engine::Source>> =
                 vec![Box::new(walkforward_window_source(from, to))];
@@ -508,12 +519,12 @@ fn sweep_over(from: Timestamp, to: Timestamp) -> SweepFamily {
 
 /// Run the chosen params over an out-of-sample window; return the recorded
 /// pip-equity segment (for stitching) and the OOS RunReport (the C18 record).
-fn run_oos(params: &[Scalar], from: Timestamp, to: Timestamp) -> (Vec<(Timestamp, f64)>, RunReport) {
+fn run_oos(params: &[Cell], from: Timestamp, to: Timestamp) -> (Vec<(Timestamp, f64)>, RunReport) {
     let (bp, rx_eq, rx_ex) = sample_blueprint_with_sinks();
     let space = bp.param_space();
     let mut h = bp
-        .bootstrap_with_params(params.to_vec())
-        .expect("chosen params are kind-checked against param_space");
+        .bootstrap_with_cells(params)
+        .expect("chosen params pre-validated by the in-sample GridSpace::new");
     let sources: Vec<Box<dyn aura_engine::Source>> =
         vec![Box::new(walkforward_window_source(from, to))];
     let window = window_of(&sources).expect("non-empty out-of-sample window");