feat: expand rust parity, wasm exports, and api conformance

Move several hot Python analysis paths to Rust-backed helpers. This adds Rust implementations for backtest strategy signal generation and the core portfolio loop, options and futures payoff aggregation, Greeks aggregation, ratio calculation, trade extraction, chunked close-only indicator runs, and forward-fill helpers. Wire the Python analysis and data modules to prefer these paths, and add coverage for the new batch fast path.

Expand the WASM package to export WMA, ADX, and MFI from ferro_ta_core, refresh the Node examples, benchmarks, and README, and add a Node-vs-Python conformance test so the browser and node surface stays aligned with the main Python package.

Introduce a generated cross-surface API manifest in docs/, along with scripts to rebuild and verify it from source exports. Enforce manifest freshness in the Python and WASM CI workflows so release candidates catch surface drift before push.

python/ferro_ta/data/chunked.py

@@ -27,6 +27,7 @@ Rust backend
     ferro_ta._ferro_ta.make_chunk_ranges
     ferro_ta._ferro_ta.trim_overlap
     ferro_ta._ferro_ta.stitch_chunks
+    ferro_ta._ferro_ta.chunk_apply_close_indicator
 
 Notes
 -----
@@ -49,6 +50,9 @@ from typing import Any
 import numpy as np
 from numpy.typing import ArrayLike, NDArray
 
+from ferro_ta._ferro_ta import (
+    chunk_apply_close_indicator as _rust_chunk_apply_close_indicator,
+)
 from ferro_ta._ferro_ta import (
     make_chunk_ranges as _rust_make_chunk_ranges,
 )
@@ -67,6 +71,26 @@ __all__ = [
     "stitch_chunks",
 ]
 
+_FASTPATH_DEFAULT_PERIODS: dict[str, int] = {
+    "SMA": 30,
+    "EMA": 30,
+    "RSI": 14,
+}
+
+
+def _resolve_chunk_fastpath(
+    fn: Callable[..., Any], fn_kwargs: dict[str, Any]
+) -> tuple[str, int] | None:
+    name = getattr(fn, "__name__", "").upper()
+    if name not in _FASTPATH_DEFAULT_PERIODS:
+        return None
+    if set(fn_kwargs) - {"timeperiod"}:
+        return None
+    raw = fn_kwargs.get("timeperiod", _FASTPATH_DEFAULT_PERIODS[name])
+    if not isinstance(raw, int):
+        return None
+    return name, int(raw)
+
 
 def make_chunk_ranges(
     n: int,
@@ -190,6 +214,20 @@ def chunk_apply(
     if n == 0:
         return np.empty(0, dtype=np.float64)
 
+    fastpath = _resolve_chunk_fastpath(fn, fn_kwargs)
+    if fastpath is not None:
+        indicator, timeperiod = fastpath
+        return np.asarray(
+            _rust_chunk_apply_close_indicator(
+                np.ascontiguousarray(s),
+                indicator,
+                int(timeperiod),
+                int(chunk_size),
+                int(overlap),
+            ),
+            dtype=np.float64,
+        )
+
     ranges = make_chunk_ranges(n, chunk_size, overlap)
     if len(ranges) == 0:
         result = fn(s, **fn_kwargs)