perf: Cythonize autorun functionality, add awaitable wrapper, and introduce performance benchmarks.

Author: zytegalaxy

CYTHON_README.md

@@ -29,6 +29,19 @@ Performance comparison between the Pure Python baseline and the Hyper-Optimized
 
 The **4.65x speedup** for subscribers is a result of "Hyper Optimization" (Phase 8), which eliminated 66% of the overhead associated with checking for coroutines in synchronous listeners.
 
+## Autorun Optimization (Phase 9)
+
+In Phase 9, we fully Cythonized the `Autorun` class, embedding it directly within `_store_core.pyx` to access internal store state efficiently.
+
+| Test Case | Baseline (Python) | Optimized (Cython) | Speedup |
+|-----------|-------------------|--------------------|-------------|
+| **Autorun Creation** | 52.6 μs | 15.5 μs | **3.40x** |
+| **Reactivity Check** | 9.6 μs | 5.6 μs | **1.71x** |
+| **Complex Selector** | 9.7 μs | 5.9 μs | **1.64x** |
+| **Notifications** | 668 μs | 383 μs | **1.74x** |
+
+This provides substantial improvements for applications that rely heavily on reactive state derived from the store.
+
 ## Build & Reproduction
 
 To reproduce these results, you can build the extension and run the benchmarks.
@@ -64,4 +77,5 @@ pytest-benchmark compare baseline.json optimized.json
 -   `redux/_store_core.pyx`: The optimized Cython `Store` implementation.
 -   `redux/_store_py.py`: The pure Python fallback.
 -   `redux/main.py`: The selector module that handles the import logic.
--   `benchmarks/bench_dispatch.py`: The performance test suite.
+-   `benchmarks/bench_dispatch.py`: The performance test suite for dispatch.
+-   `benchmarks/bench_autorun.py`: The performance test suite for Autorun.

benchmarks/bench_autorun.py

@@ -0,0 +1,71 @@
+
+import pytest
+from redux.main import Store
+from redux.basic_types import BaseAction, StoreOptions
+from dataclasses import replace, field
+from immutable import Immutable
+
+class State(Immutable):
+    value: int
+    nested: dict = field(default_factory=dict)
+
+class IncrementAction(BaseAction):
+    pass
+
+def reducer(state, action):
+    if state is None:
+        return State(value=0)
+    if isinstance(action, IncrementAction):
+        return replace(state, value=state.value + 1)
+    return state
+
+@pytest.fixture
+def store():
+    return Store(reducer, options=StoreOptions(auto_init=True))
+
+def test_autorun_creation(benchmark, store):
+    """Benchmark creating autoruns."""
+    
+    def run():
+        @store.autorun(lambda s: s.value)
+        def _(val):
+            pass
+
+    benchmark(run)
+
+def test_autorun_reactivity(benchmark, store):
+    """Benchmark autorun reaction overhead."""
+    
+    @store.autorun(lambda s: s.value)
+    def _(val):
+        pass
+    
+    def run():
+        store.dispatch(IncrementAction())
+
+    benchmark(run)
+
+def test_autorun_complex_selector(benchmark, store):
+    """Benchmark autorun with complex selector."""
+    
+    @store.autorun(lambda s: s.value * 2 + (s.nested.get('a', 0) or 0))
+    def _(val):
+        pass
+
+    def run():
+        store.dispatch(IncrementAction())
+
+    benchmark(run)
+
+def test_autorun_many_subscribers(benchmark, store):
+    """Benchmark notification of many autoruns."""
+    
+    for _ in range(100):
+        @store.autorun(lambda s: s.value)
+        def _(val):
+            pass
+
+    def run():
+        store.dispatch(IncrementAction())
+
+    benchmark(run)