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>

hosts/ocaml/bootstrap.py

@@ -90,18 +90,17 @@ let cek_run_iterative state =
 
 def compile_spec_to_ml(spec_dir: str | None = None) -> str:
     """Compile the SX spec to OCaml source."""
-    from shared.sx.ref.sx_ref import eval_expr, trampoline, make_env, sx_parse
+    import tempfile
+    from shared.sx.ocaml_sync import OcamlSync
+    from shared.sx.parser import serialize
 
     if spec_dir is None:
         spec_dir = os.path.join(_PROJECT, "spec")
 
-    # Load the transpiler
-    env = make_env()
+    # Load the transpiler into OCaml kernel
+    bridge = OcamlSync()
     transpiler_path = os.path.join(_HERE, "transpiler.sx")
-    with open(transpiler_path) as f:
-        transpiler_src = f.read()
-    for expr in sx_parse(transpiler_src):
-        trampoline(eval_expr(expr, env))
+    bridge.load(transpiler_path)
 
     # Spec files to transpile (in dependency order)
     # stdlib.sx functions are already registered as OCaml primitives —
@@ -138,21 +137,29 @@ def compile_spec_to_ml(spec_dir: str | None = None) -> str:
             seen[n] = i
         defines = [(n, e) for i, (n, e) in enumerate(defines) if seen[n] == i]
 
-        # Build the defines list for the transpiler
+        # Build the defines list and known names for the transpiler
         defines_list = [[name, expr] for name, expr in defines]
-        env["_defines"] = defines_list
+        known_names = [name for name, _ in defines]
 
-        # Pass known define names so the transpiler can distinguish
-        # static (OCaml fn) calls from dynamic (SX value) calls
-        env["_known_defines"] = [name for name, _ in defines]
+        # Serialize defines + known names to temp file, load into kernel
+        defines_sx = serialize(defines_list)
+        known_sx = serialize(known_names)
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".sx", delete=False) as tmp:
+            tmp.write(f"(define _defines \'{defines_sx})\n")
+            tmp.write(f"(define _known_defines \'{known_sx})\n")
+            tmp_path = tmp.name
+        try:
+            bridge.load(tmp_path)
+        finally:
+            os.unlink(tmp_path)
 
         # Call ml-translate-file — emits as single let rec block
-        translate_expr = sx_parse("(ml-translate-file _defines)")[0]
-        result = trampoline(eval_expr(translate_expr, env))
+        result = bridge.eval("(ml-translate-file _defines)")
 
         parts.append(f"\n(* === Transpiled from {label} === *)\n")
         parts.append(result)
 
+    bridge.stop()
     parts.append(FIXUPS)
     output = "\n".join(parts)