Complete Python eval removal: epoch protocol, scope consolidation, JIT fixes

Route all rendering through OCaml bridge — render_to_html no longer uses
Python async_eval. Fix register_components to parse &key params and &rest
children from defcomp forms. Remove all dead sx_ref.py imports.

Epoch protocol (prevents pipe desync):
- Every command prefixed with (epoch N), all responses tagged with epoch
- Both sides discard stale-epoch messages — desync structurally impossible
- OCaml main loop discards stale io-responses between commands

Consolidate scope primitives into sx_scope.ml:
- Single source of truth for scope-push!/pop!/peek, collect!/collected,
  emit!/emitted, context, and 12 other scope operations
- Removes duplicate registrations from sx_server.ml (including bugs where
  scope-emit! and clear-collected! were registered twice with different impls)
- Bind scope prims into env so JIT VM finds them via OP_GLOBAL_GET

JIT VM fixes:
- Trampoline thunks before passing args to CALL_PRIM
- as_list resolves thunks via _sx_trampoline_fn
- len handles all value types (Bool, Number, RawHTML, SxExpr, Spread, etc.)

Other fixes:
- ~cssx/tw signature: (tokens) → (&key tokens) to match callers
- Minimal Python evaluator in html.py for sync sx() Jinja function
- Python scope primitive stubs (thread-local) for non-OCaml paths
- Reader macro resolution via OcamlSync instead of sx_ref.py

Tests: 1114 OCaml, 1078 JS, 35 Python regression, 6/6 Playwright SSR

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

shared/sx/helpers.py

@@ -385,10 +385,7 @@ async def _render_to_sx_with_env(__name: str, extra_env: dict, **kwargs: Any) ->
         ocaml_ctx = {"_helper_service": _get_request_context().get("_helper_service", "")} if isinstance(_get_request_context(), dict) else {}
         return SxExpr(await bridge.aser_slot(sx_text, ctx=ocaml_ctx))
 
-    if os.environ.get("SX_USE_REF") == "1":
-        from .ref.async_eval_ref import async_eval_slot_to_sx
-    else:
-        from .async_eval import async_eval_slot_to_sx
+    from .async_eval import async_eval_slot_to_sx
 
     env = dict(get_component_env())
     env.update(extra_env)
@@ -421,10 +418,7 @@ async def _render_to_sx(__name: str, **kwargs: Any) -> str:
         # symbols like `title` that were bound during the earlier expansion.
         return SxExpr(await bridge.aser_slot(sx_text))
 
-    if os.environ.get("SX_USE_REF") == "1":
-        from .ref.async_eval_ref import async_eval_to_sx
-    else:
-        from .async_eval import async_eval_to_sx
+    from .async_eval import async_eval_to_sx
 
     env = dict(get_component_env())
     ctx = _get_request_context()
@@ -442,15 +436,23 @@ async def render_to_html(__name: str, **kwargs: Any) -> str:
     Same as render_to_sx() but produces HTML output instead of SX wire
     format. Used by route renders that need HTML (full pages, fragments).
 
-    Note: does NOT use OCaml bridge — the shell render is a pure HTML
-    template with no IO, so the Python renderer handles it reliably.
-    The OCaml path is used for _render_to_sx and _eval_slot (IO-heavy).
+    Routes through the OCaml bridge (render mode) which handles component
+    parameter binding, scope primitives, and all evaluation.
     """
-    from .jinja_bridge import get_component_env, _get_request_context
     import os
-    from .async_eval import async_render
 
     ast = _build_component_ast(__name, **kwargs)
+
+    if os.environ.get("SX_USE_OCAML") == "1":
+        from .ocaml_bridge import get_bridge
+        from .parser import serialize
+        bridge = await get_bridge()
+        sx_text = serialize(ast)
+        return await bridge.render(sx_text)
+
+    # Fallback: Python async_eval (requires working evaluator)
+    from .jinja_bridge import get_component_env, _get_request_context
+    from .async_eval import async_render
     env = dict(get_component_env())
     ctx = _get_request_context()
     return await async_render(ast, env, ctx)