feat(data-layer): TickAggregator (tick-to-candle) in all 10 languages (#309)

* feat(data-layer): TickAggregator in Node, WASM, Python + C ABI hub

First data-layer feature (F2): roll trade ticks up into fixed-timeframe OHLCV
candles, exposed natively and over the C ABI.

- wickra-data wired as a binding dependency (workspace dep; its wickra-core dep
  is default-features=false so it never forces rayon into the rayon-free WASM
  build — native bindings re-enable parallel through their own dependency).
- Node `TickAggregator(bucket, gapFill?)` -> `push(price, size, ts): Candle[]`;
  WASM the same (array of objects); Python `push(...) -> list[tuple]`.
- C ABI: `WickraCandle` struct + `wickra_tick_aggregator_new/push/free` (push
  writes candles into a caller buffer and returns the count), generated via the
  capi generator's new DATA_LAYER section; cbindgen now parses wickra-data so
  `TickAggregator` is a forward-declared opaque; header vendored to bindings/go.

Verified bit-identical across Node/WASM/Python/C/C++ (o=100 h=101 l=100 c=101
v=3 ts=0 for the shared 3-tick probe). WIP: Go/C#/Java/R generated bindings and
the cross-language golden are still pending.

* feat(data-layer): TickAggregator in Go, C#, Java, R (lossless push/drain)

Complete F2 across all 10 languages: the C-ABI tick aggregator now uses a
two-step push/drain so gap-fill candles are never lost, and the four generated
bindings expose it idiomatically.

- C ABI redesigned: opaque TickAggregator handle (inner aggregator + pending
  buffer); push consumes a tick and returns the closed-candle count, drain copies
  them into a count-sized caller buffer.
- Go: NewTickAggregator + Push(price,size,ts) []Candle; C#: TickAggregator +
  Candle[] Push(...); Java: TickAggregator + Candle[] push(...); R: TickAggregator
  constructor + push() S3 generic returning an (n x 6) numeric matrix.
- Candle output record generated per language from WickraCandle.

Verified bit-identical to the native bindings (o=100 h=101 l=100 c=101 v=3 ts=0)
in Go, C#, Java, and R at runtime; R passes R CMD check (pre-existing doc
warnings only). WIP: cross-language data-layer golden + CHANGELOG still pending.

* test(data-layer): cross-language golden for the tick aggregator + CHANGELOG

gen_golden emits a deterministic tick stream (testdata/golden/data_ticks.csv) and
the reference candle streams with and without gap filling (data_candles.csv,
data_candles_gap.csv). Every binding replays the shared ticks through its
TickAggregator and checks the candles bit-for-bit (fp tolerance) against the Rust
reference:

- Node / WASM / Python / Go / C# / Java / R: a dedicated parity test each.
- C / C++: data_layer_test.c (compiled as both, run as ctest).

The gap-fill fixture closes several candles from a single push, exercising the
lossless push/drain path. Records the feature under CHANGELOG [Unreleased].

* fix(examples): rename the CSV-loader candle to WickraBar

The example CSV helper (wickra_csv.h) defined its own struct WickraCandle, which
now collides with the public C ABI WickraCandle (the tick aggregator output) in
any example that includes both headers (backtest, multi_timeframe, the strategy
examples). The public type owns the name; rename the example loader's bar to
WickraBar. The generated golden_test.c is untouched (its only match was the
unrelated WickraCandleVolumeOutput).

examples/rust/src/bin/gen_golden.rs

@@ -17,8 +17,9 @@ use std::path::Path;
 
 use wickra::{
     AdOscillator, Adx, Atr, AverageDrawdown, AwesomeOscillatorHistogram, Beta, Candle, Ema,
-    Indicator, IntradayIntensity, MacdIndicator, Rsi, Sma,
+    Indicator, IntradayIntensity, MacdIndicator, Rsi, Sma, Tick,
 };
+use wickra_data::aggregator::{TickAggregator, Timeframe};
 
 const N: usize = 80;
 
@@ -183,9 +184,52 @@ fn main() {
     emit_special(dir, &candles);
     emit_profiles(dir, &candles);
     emit_bars(dir, &candles);
+    emit_data_layer(dir);
     println!("golden fixtures written to {}", dir.display());
 }
 
+/// Deterministic trade tick `i`: price on the shared varied path, a small
+/// repeating size, and a timestamp that places roughly three ticks per
+/// 1000-unit bucket. A deliberate jump at `i == 36` opens a multi-bucket gap so
+/// the gap-fill fixture exercises several flat candles emitted from one push.
+fn tick(i: usize) -> (f64, f64, i64) {
+    let t = i as f64;
+    let price = 100.0 + 10.0 * (t * 0.3).sin() + 0.5 * t;
+    let size = 1.0 + (i % 5) as f64;
+    let base = i64::try_from(i).expect("tick index fits i64") * 350;
+    let ts = if i >= 36 { base + 5000 } else { base };
+    (price, size, ts)
+}
+
+/// Data layer: the tick-to-candle aggregator. Writes the shared tick input plus
+/// the reference candle streams with and without gap filling.
+fn emit_data_layer(dir: &Path) {
+    const N_TICKS: usize = 60;
+    let ticks: Vec<(f64, f64, i64)> = (0..N_TICKS).map(tick).collect();
+
+    let mut tin = Vec::with_capacity(N_TICKS);
+    for &(price, size, ts) in &ticks {
+        tin.push(format!("{price},{size},{ts}"));
+    }
+    write_csv(dir, "data_ticks", "price,size,timestamp", &tin);
+
+    let header = "open,high,low,close,volume,timestamp";
+    for (name, gap_fill) in [("data_candles", false), ("data_candles_gap", true)] {
+        let mut agg = TickAggregator::new(Timeframe::new(1000).unwrap()).with_gap_fill(gap_fill);
+        let mut rows = Vec::new();
+        for &(price, size, ts) in &ticks {
+            let tick = Tick::new(price, size, ts).expect("valid tick");
+            for c in agg.push(tick).expect("valid push") {
+                rows.push(format!(
+                    "{},{},{},{},{},{}",
+                    c.open, c.high, c.low, c.close, c.volume, c.timestamp
+                ));
+            }
+        }
+        write_csv(dir, name, header, &rows);
+    }
+}
+
 // AUTO-GENERATED scalar-output golden tranche (single f64 output).
 #[allow(clippy::too_many_lines)]
 fn emit_scalar(dir: &Path, candles: &[Candle], closes: &[f64]) {