refactor(aura-core): split Scalar into a tag-free Cell + ScalarKind

Motivation
----------
`Scalar` was a tagged enum (I64/F64/Bool/Ts), so every scalar value
physically carried its own kind tag. But the kind is already known from
the schema/port/column the value flows through (C7: the type is a
property of the column, not of the value — the hot path is already
columnar `Column<T>`, and `AnyColumn::get` *reconstructs* the tag from
the column on the way out). The per-value tag was therefore redundant
with the kind the surrounding context already holds.

That redundancy had three costs:

  * It baked an implicit `match` (a branch) into every function that read
    a Scalar payload — even where the caller statically knew the type.
    The tag could never be exploited away.
  * Size: a tagged enum is tag + payload = 16 bytes (f64/i64 alignment),
    twice the 8 bytes the value needs. A `Column<Scalar>` would be double
    the memory and half the cache utilisation.
  * It is the shared root of several downstream papercuts we keep hitting
    — the lossy f64 manifest field, the `unreachable!` panic on a
    non-numeric param, the serde-tag question — all symptoms of "the type
    is baked into the value".

Change
------
Introduce `Cell`: a type-erased 64-bit word (`struct Cell(u64)`) that is
not readable without external type context. It is constructed per base
type (`from_i64/from_f64/from_bool/from_ts`) and read only by naming the
type at the call site (`i64()/f64()/bool()/ts()`) — each a branch-free
bit-cast. The hot path resolves the kind once at the boundary (from the
schema) and then reads natively, with no per-value branch. `Cell` knows
nothing of `Scalar` or `ScalarKind`; the dependency is strictly one-way,
and it lives in its own `cell.rs` (more is planned on top of it).

`Scalar` becomes `struct { kind: ScalarKind, cell: Cell }` — the
self-describing form for the dynamic boundaries (builder binding,
serialization, rendering), built on top of `Cell`. Its `as_*` accessors
now `debug_assert` the kind and return the native value (free in
release); calling the wrong accessor is a caller bug, not a checked
`Option`. The variant constructors `Scalar::I64(..)` become associated
fns `Scalar::i64(..)`.

`PartialEq` is hand-written (not derived) to preserve the former enum's
value semantics: kinds must match, then native payloads compare, so f64
keeps IEEE-754 behaviour (`NaN != NaN`, `+0.0 == -0.0`) and a kind
mismatch is never equal even when the raw words coincide. A fixture
(`scalar_eq_is_value_not_bitwise`) pins exactly the cases where bit- and
value-equality diverge, so it can't silently regress. `Cell`'s own
`Eq`/`Hash` stay bitwise — correct for a raw word.

The change is behaviour-preserving: Scalar's observable behaviour is
identical to the pre-Cell enum (the value-equality fixture proves it);
only the internal representation changed. The ~440 call sites across the
workspace are a mechanical constructor rename plus ~12 destructuring
sites (match-arms / `let`-patterns) rewritten to `kind()` + `as_*`.

Verified: cargo build --workspace --all-targets, cargo clippy --workspace
--all-targets -- -D warnings, cargo test --workspace — all green.

crates/aura-std/src/ema.rs

@@ -49,7 +49,7 @@ impl Ema {
             warmup_sum: 0.0,
             count: 0,
             ema: 0.0,
-            out: [Scalar::F64(0.0)],
+            out: [Scalar::f64(0.0)],
         }
     }
 
@@ -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().expect("length slot is I64") as usize)),
+            |p| Box::new(Ema::new(p[0].as_i64() as usize)),
         )
     }
 }
@@ -96,7 +96,7 @@ impl Node for Ema {
             // O(1) recurrence: one sub, one mul, one add.
             self.ema += self.alpha * (x - self.ema);
         }
-        self.out[0] = Scalar::F64(self.ema);
+        self.out[0] = Scalar::f64(self.ema);
         Some(&self.out)
     }
 
@@ -124,11 +124,11 @@ mod tests {
         let expect = [None, None, Some(4.0), Some(7.0)];
 
         for (v, want) in feed.iter().zip(expect) {
-            inputs[0].push(Scalar::F64(*v)).unwrap();
+            inputs[0].push(Scalar::f64(*v)).unwrap();
             let got = ema.eval(Ctx::new(&inputs, Timestamp(0)));
             match want {
                 None => assert_eq!(got, None),
-                Some(m) => assert_eq!(got, Some([Scalar::F64(m)].as_slice())),
+                Some(m) => assert_eq!(got, Some([Scalar::f64(m)].as_slice())),
             }
         }
     }
@@ -140,11 +140,11 @@ mod tests {
         let mut ema = Ema::new(1);
         let mut inputs = vec![AnyColumn::with_capacity(ScalarKind::F64, 1)];
 
-        inputs[0].push(Scalar::F64(7.0)).unwrap();
-        assert_eq!(ema.eval(Ctx::new(&inputs, Timestamp(0))), Some([Scalar::F64(7.0)].as_slice()));
+        inputs[0].push(Scalar::f64(7.0)).unwrap();
+        assert_eq!(ema.eval(Ctx::new(&inputs, Timestamp(0))), Some([Scalar::f64(7.0)].as_slice()));
 
-        inputs[0].push(Scalar::F64(9.0)).unwrap();
-        assert_eq!(ema.eval(Ctx::new(&inputs, Timestamp(0))), Some([Scalar::F64(9.0)].as_slice()));
+        inputs[0].push(Scalar::f64(9.0)).unwrap();
+        assert_eq!(ema.eval(Ctx::new(&inputs, Timestamp(0))), Some([Scalar::f64(9.0)].as_slice()));
     }
 
     #[test]