feat(data-layer): Resampler (candle resampling) in all 10 languages (#310)

* feat(data-layer): Resampler (candle resampling) in all 10 languages

Second data-layer feature (F3): resample candles into a higher timeframe.

- Native (Node.js/WASM): new Resampler(timeframe) -> update(o,h,l,c,v,ts):
  Candle|null + flush(): Candle|null. Python the same -> tuple|None.
- C ABI: wickra_resampler_new/update/flush/free (update has the multi-output
  shape so the generators auto-emit it; flush is bespoke). Go Update -> (Candle,
  bool) + Flush; C# Candle? Update/Flush; Java Candle update/flush; R update()
  generic + a flush() S3 method (extends base::flush); C/C++ direct.
- Cross-language golden (testdata/golden/data_resampled.csv): the shared input
  candles resampled into 5-unit buckets, the final partial bucket via flush,
  pinned bit-for-bit across every binding.

Verified locally in all 10 (3 candles for the 5-unit smoke; 16 for the golden).
The WickraCandle output record is shared with the tick aggregator (deduped).

* test(node): exclude data-layer types from the indicator completeness contract

The Resampler exposes update(), so the completeness test flagged it as an
indicator and required batch/reset/isReady/warmupPeriod, which a data-layer type
does not have. Exclude TickAggregator and Resampler like the bar builders.

examples/rust/src/bin/gen_golden.rs

@@ -20,6 +20,7 @@ use wickra::{
     Indicator, IntradayIntensity, MacdIndicator, Rsi, Sma, Tick,
 };
 use wickra_data::aggregator::{TickAggregator, Timeframe};
+use wickra_data::resample::Resampler;
 
 const N: usize = 80;
 
@@ -185,9 +186,37 @@ fn main() {
     emit_profiles(dir, &candles);
     emit_bars(dir, &candles);
     emit_data_layer(dir);
+    emit_resampler(dir, &candles);
     println!("golden fixtures written to {}", dir.display());
 }
 
+/// Data layer: the resampler. Resamples the shared input candles (timestamp =
+/// row index) into 5-unit buckets; the final partial bucket comes out of flush.
+fn emit_resampler(dir: &Path, candles: &[Candle]) {
+    let mut resampler = Resampler::new(Timeframe::new(5).unwrap());
+    let mut rows = Vec::new();
+    for &candle in candles {
+        if let Some(out) = resampler.push(candle).expect("valid resample push") {
+            rows.push(format!(
+                "{},{},{},{},{},{}",
+                out.open, out.high, out.low, out.close, out.volume, out.timestamp
+            ));
+        }
+    }
+    if let Some(out) = resampler.flush().expect("valid resample flush") {
+        rows.push(format!(
+            "{},{},{},{},{},{}",
+            out.open, out.high, out.low, out.close, out.volume, out.timestamp
+        ));
+    }
+    write_csv(
+        dir,
+        "data_resampled",
+        "open,high,low,close,volume,timestamp",
+        &rows,
+    );
+}
+
 /// 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