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-engine/src/report.rs

@@ -8,7 +8,7 @@
 //! cycle 0029) — the same encoder the run registry uses, so a record's stdout
 //! and on-disk shapes coincide.
 
-use aura_core::{Scalar, Timestamp};
+use aura_core::{Scalar, ScalarKind, Timestamp};
 
 /// Summary metrics reduced from a run's recorded streams — the `-> metrics`
 /// half of C12's atomic sim unit. Pure function of the recorded streams.
@@ -134,10 +134,10 @@ pub fn f64_field(rows: &[(Timestamp, Vec<Scalar>)], field: usize) -> Vec<(Timest
             let Some(&scalar) = row.get(field) else {
                 panic!("f64_field: row has no field {field} (row width {})", row.len());
             };
-            let Scalar::F64(v) = scalar else {
+            if scalar.kind() != ScalarKind::F64 {
                 panic!("f64_field: field {field} is not an f64 scalar: {scalar:?}");
-            };
-            (*ts, v)
+            }
+            (*ts, scalar.as_f64())
         })
         .collect()
 }
@@ -164,7 +164,7 @@ mod tests {
     /// harness.rs test helper; the e2e test needs its own copy — the harness
     /// test module's is private to that module).
     fn f64_stream(points: &[(i64, f64)]) -> Vec<(Timestamp, Scalar)> {
-        points.iter().map(|&(t, v)| (Timestamp(t), Scalar::F64(v))).collect()
+        points.iter().map(|&(t, v)| (Timestamp(t), Scalar::f64(v))).collect()
     }
 
     /// Bootstrap the cycle-0007 signal-quality harness with TWO sinks: one on
@@ -316,8 +316,8 @@ mod tests {
     #[test]
     fn f64_field_projects_the_named_field() {
         let rows = vec![
-            (Timestamp(1), vec![Scalar::F64(1.5), Scalar::I64(9)]),
-            (Timestamp(2), vec![Scalar::F64(2.5), Scalar::I64(8)]),
+            (Timestamp(1), vec![Scalar::f64(1.5), Scalar::i64(9)]),
+            (Timestamp(2), vec![Scalar::f64(2.5), Scalar::i64(8)]),
         ];
         assert_eq!(
             f64_field(&rows, 0),
@@ -328,7 +328,7 @@ mod tests {
     #[test]
     #[should_panic(expected = "not an f64 scalar")]
     fn f64_field_panics_on_kind_mismatch() {
-        let rows = vec![(Timestamp(1), vec![Scalar::I64(7)])];
+        let rows = vec![(Timestamp(1), vec![Scalar::i64(7)])];
         let _ = f64_field(&rows, 0);
     }