feat(aura-engine): Source ingestion seam — run() takes Vec<Box<dyn Source>>

The engine's ingestion input was the only type encoding an eager-dataflow
assumption: `Harness::run(Vec<Vec<(Timestamp, Scalar)>>)` — one fully
materialized stream per source. At realistic research scale (20y, 3 tick
streams, ~7.9e9 ticks) that layout is ~190 GB resident, non-residable. Yet
the merge loop never needs the whole stream: it only ever peeks the head
timestamp of each live source and pops one record. So the eager Vec is
gratuitous.

This lands the first half of the Source seam (plan Tasks 1-2):

  - A `Source` trait (`peek(&self) -> Option<Timestamp>`,
    `next(&mut) -> Option<(Timestamp, Scalar)>`), object-safe so the merge
    holds `Vec<Box<dyn Source>>`. The peek/next split is the producer contract
    the k-way merge drives.
  - `VecSource`, an adapter over the old `Vec<(Timestamp, Scalar)>` — the
    cycle-0011 eager shape, named. It IS the old behaviour.
  - `Harness::run` re-typed to `Vec<Box<dyn Source>>`; the merge loop's index
    arithmetic becomes peek/next. C4 tie-by-source-index is preserved (the
    strictly-`<` replace + source-order scan is byte-for-byte the old
    semantics). The forward+eval body is unchanged.
  - All 53 call sites threaded VecSource-wrapped in the same change, so the
    workspace compiles atomically and run output is byte-identical (C1).

Behaviour-preserving is the load-bearing guarantee: the full suite is green
and unchanged (the two-run C1 determinism pairs — real_bars r1/r2, blueprint
sweep-equality, harness h/h2 — stay byte-identical); aura-engine unit tests
129 -> 132 (+3 VecSource unit tests). No residency change yet: VecSource holds
the same Vec as before. The lazy data-server-backed streaming source and its
end-to-end residency proof are the second half (plan Tasks 3-4).

refs #71

crates/aura-cli/src/main.rs

@@ -11,7 +11,7 @@ mod render;
 use aura_core::{Firing, Scalar, ScalarKind, Timestamp};
 use aura_engine::{
     f64_field, summarize, Composite, Edge, FlatGraph, GraphBuilder, Harness,
-    RunManifest, RunReport, SourceSpec, SweepFamily, Target,
+    RunManifest, RunReport, SourceSpec, SweepFamily, Target, VecSource,
 };
 use aura_registry::{rank_by, Registry};
 use aura_std::{Ema, Exposure, LinComb, Recorder, SimBroker, Sma, Sub};
@@ -137,7 +137,7 @@ fn run_sample() -> RunReport {
         prices.first().expect("non-empty stream").0,
         prices.last().expect("non-empty stream").0,
     );
-    h.run(vec![prices]);
+    h.run(vec![Box::new(VecSource::new(prices))]);
 
     let eq_rows: Vec<(Timestamp, Vec<Scalar>)> = rx_eq.try_iter().collect();
     let ex_rows: Vec<(Timestamp, Vec<Scalar>)> = rx_ex.try_iter().collect();
@@ -280,7 +280,7 @@ fn sweep_family() -> SweepFamily {
                 prices.first().expect("non-empty stream").0,
                 prices.last().expect("non-empty stream").0,
             );
-            h.run(vec![prices]);
+            h.run(vec![Box::new(VecSource::new(prices))]);
             let equity = f64_field(&rx_eq.try_iter().collect::<Vec<_>>(), 0);
             let exposure = f64_field(&rx_ex.try_iter().collect::<Vec<_>>(), 0);
             let params = space
@@ -459,7 +459,7 @@ fn run_macd() -> RunReport {
         prices.first().expect("non-empty stream").0,
         prices.last().expect("non-empty stream").0,
     );
-    h.run(vec![prices]);
+    h.run(vec![Box::new(VecSource::new(prices))]);
 
     let eq_rows: Vec<(Timestamp, Vec<Scalar>)> = rx_eq.try_iter().collect();
     let ex_rows: Vec<(Timestamp, Vec<Scalar>)> = rx_ex.try_iter().collect();
@@ -524,7 +524,7 @@ mod tests {
             .with("exposure.scale", 0.5)
             .bootstrap()
             .expect("sample blueprint compiles under a valid point");
-        h.run(vec![showcase_prices()]);
+        h.run(vec![Box::new(VecSource::new(showcase_prices()))]);
         assert!(!rx_eq.try_iter().collect::<Vec<_>>().is_empty(), "equity sink drained empty");
         assert!(!rx_ex.try_iter().collect::<Vec<_>>().is_empty(), "exposure sink drained empty");
     }