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-std/src/ema.rs

@@ -64,7 +64,7 @@ impl Ema {
                 output: vec![FieldSpec { name: "value".into(), kind: ScalarKind::F64 }],
                 params: vec![ParamSpec { name: "length".into(), kind: ScalarKind::I64 }],
             },
-            |p| Box::new(Ema::new(p[0].as_i64() as usize)),
+            |p| Box::new(Ema::new(p[0].i64() as usize)),
         )
     }
 }

crates/aura-std/src/exposure.rs

@@ -33,7 +33,7 @@ impl Exposure {
                 output: vec![FieldSpec { name: "exposure".into(), kind: ScalarKind::F64 }],
                 params: vec![ParamSpec { name: "scale".into(), kind: ScalarKind::F64 }],
             },
-            |p| Box::new(Exposure::new(p[0].as_f64())),
+            |p| Box::new(Exposure::new(p[0].f64())),
         )
     }
 }

crates/aura-std/src/lincomb.rs

@@ -54,7 +54,7 @@ impl LinComb {
             "LinComb",
             NodeSchema { inputs, output: vec![FieldSpec { name: "value".into(), kind: ScalarKind::F64 }], params },
             |p| Box::new(LinComb::new(
-                p.iter().map(|s| s.as_f64()).collect(),
+                p.iter().map(|c| c.f64()).collect(),
             )),
         )
     }
@@ -173,7 +173,7 @@ mod tests {
             partial.params().iter().map(|p| p.name.as_str()).collect::<Vec<_>>(),
             ["weights[1]"],
         );
-        let mut lc2 = partial.build(&[Scalar::f64(2.0)]); // weights[1] = 2.0 injected
+        let mut lc2 = partial.build(&[Cell::from_f64(2.0)]); // weights[1] = 2.0 injected
         let mut inputs2 = vec![
             AnyColumn::with_capacity(ScalarKind::F64, 1),
             AnyColumn::with_capacity(ScalarKind::F64, 1),

crates/aura-std/src/sma.rs

@@ -32,7 +32,7 @@ impl Sma {
                 output: vec![FieldSpec { name: "value".into(), kind: ScalarKind::F64 }],
                 params: vec![ParamSpec { name: "length".into(), kind: ScalarKind::I64 }],
             },
-            |p| Box::new(Sma::new(p[0].as_i64() as usize)),
+            |p| Box::new(Sma::new(p[0].i64() as usize)),
         )
     }
 }