Delete sx_ref.py — OCaml is the sole SX evaluator

Removes the 5993-line bootstrapped Python evaluator (sx_ref.py) and all
code that depended on it exclusively. Both bootstrappers (JS + OCaml)
now use a new synchronous OCaml bridge (ocaml_sync.py) to run the
transpiler. JS build produces identical output; OCaml bootstrap produces
byte-identical sx_ref.ml.

Key changes:
- New shared/sx/ocaml_sync.py: sync subprocess bridge to sx_server.exe
- hosts/javascript/bootstrap.py: serialize defines → temp file → OCaml eval
- hosts/ocaml/bootstrap.py: same pattern for OCaml transpiler
- shared/sx/{html,async_eval,resolver,jinja_bridge,handlers,pages,deps,helpers}:
  stub or remove sx_ref imports; runtime uses OCaml bridge (SX_USE_OCAML=1)
- sx/sxc/pages: parse defpage/defhandler from AST instead of Python eval
- hosts/ocaml/lib/sx_primitives.ml: append handles non-list 2nd arg per spec
- Deleted: sx_ref.py, async_eval_ref.py, 6 Python test runners, misc ref/ files

Test results: JS 1078/1078, OCaml 1114/1114.
sx_docs SSR has pre-existing rendering issues to investigate separately.

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

shared/sx/handlers.py

@@ -80,30 +80,76 @@ def clear_handlers(service: str | None = None) -> None:
 # Loading — parse .sx files and collect HandlerDef instances
 # ---------------------------------------------------------------------------
 
+def _parse_defhandler(expr: list) -> HandlerDef | None:
+    """Extract HandlerDef from a (defhandler name :path ... (&key ...) body) form."""
+    from .types import Keyword
+    if len(expr) < 3:
+        return None
+    name = expr[1].name if hasattr(expr[1], 'name') else str(expr[1])
+
+    # Parse keyword options and find params/body
+    path = None
+    method = "get"
+    csrf = True
+    returns = "element"
+    params_list = None
+    body = None
+
+    i = 2
+    while i < len(expr):
+        item = expr[i]
+        if isinstance(item, Keyword) and i + 1 < len(expr):
+            kn = item.name
+            val = expr[i + 1]
+            if kn == "path":
+                path = val if isinstance(val, str) else str(val)
+            elif kn == "method":
+                method = val.name if hasattr(val, 'name') else str(val)
+            elif kn == "csrf":
+                csrf = val not in (False, "false")
+            elif kn == "returns":
+                returns = val if isinstance(val, str) else str(val)
+            i += 2
+        elif isinstance(item, list) and not params_list:
+            # This is the params list (&key ...)
+            params_list = item
+            i += 1
+        else:
+            body = item
+            i += 1
+
+    param_names = []
+    if params_list:
+        for p in params_list:
+            if hasattr(p, 'name') and p.name not in ("&key", "&rest"):
+                param_names.append(p.name)
+
+    return HandlerDef(
+        name=name, params=param_names, body=body or [],
+        path=path, method=method, csrf=csrf, returns=returns,
+    )
+
+
 def load_handler_file(filepath: str, service_name: str) -> list[HandlerDef]:
     """Parse an .sx file, evaluate it, and register any HandlerDef values."""
     from .parser import parse_all
     import os
-    from .ref.sx_ref import eval_expr as _raw_eval, trampoline as _trampoline
-    _eval = lambda expr, env: _trampoline(_raw_eval(expr, env))
     from .jinja_bridge import get_component_env
 
     with open(filepath, encoding="utf-8") as f:
         source = f.read()
 
-    # Seed env with component definitions so handlers can reference components
-    env = dict(get_component_env())
+    # Parse defhandler forms from the AST to extract handler registration info
     exprs = parse_all(source)
     handlers: list[HandlerDef] = []
 
     for expr in exprs:
-        _eval(expr, env)
-
-    # Collect all HandlerDef values from the env
-    for key, val in env.items():
-        if isinstance(val, HandlerDef):
-            register_handler(service_name, val)
-            handlers.append(val)
+        if (isinstance(expr, list) and expr
+                and hasattr(expr[0], 'name') and expr[0].name == "defhandler"):
+            hd = _parse_defhandler(expr)
+            if hd:
+                register_handler(service_name, hd)
+                handlers.append(hd)
 
     return handlers