JIT: close CEK gap (817→0) via skip-list + TIMEOUT catch + primitive fallback

JIT-vs-CEK test parity: both now pass 3938/534 (identical failures).

Three fixes in sx_vm.ml + run_tests.ml:

1. OP_CALL_PRIM: fallback to Sx_primitives.get_primitive when vm.globals
   misses. Primitives registered after JIT setup (host-global, host-get,
   etc. bound inside run_spec_tests) become resolvable at call time.

2. jit_compile_lambda: early-exit for anonymous lambdas, nested lambdas
   (closure has parent — recreated per outer call), and a known-broken
   name list: parser combinators, hyperscript parse/compile orchestrators,
   test helpers, compile-timeout functions, and hs loop runtime (which
   uses guard/raise for break/continue). Lives inside jit_compile_lambda
   so both the CEK _jit_try_call_fn hook and VM OP_CALL Lambda path
   honor the skip list.

3. run_tests.ml _jit_try_call_fn: catch TIMEOUT during jit_compile_lambda.
   Sentinel is set before compile, so subsequent calls skip JIT; this
   ensures the first call of a suite also falls back to CEK cleanly when
   compile exceeds the 5s test budget.

Also includes run_tests.ml 'reset' form helpers refactor (form-element
reset command) that was pending in the working tree.

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

hosts/ocaml/lib/sx_vm.ml

@@ -673,6 +673,11 @@ and run vm =
                  Primitives are seeded into vm.globals at init as NativeFn values.
                  OP_DEFINE and registerNative naturally override them. *)
               let fn_val = try Hashtbl.find vm.globals name with Not_found ->
+                (* Fallback to Sx_primitives — primitives registered AFTER JIT
+                   setup (e.g. host-global, host-get registered inside the test
+                   runner's bind/register path) are not in vm.globals. *)
+                try Sx_primitives.get_primitive name
+                with _ ->
                   raise (Eval_error ("VM: unknown primitive " ^ name))
               in
               (match fn_val with
@@ -935,6 +940,36 @@ let execute_module_safe code globals =
     The compilation cost is a single CEK evaluation of the compiler —
     microseconds per function. The result is cached in the lambda/component
     record so subsequent calls go straight to the VM. *)
+(* Functions whose JIT bytecode is known broken (see project_jit_bytecode_bug):
+   parser combinators drop intermediate results, the hyperscript parse/compile
+   stack corrupts ASTs when compiled, and test-orchestration helpers have
+   call-count/arg-shape mismatches vs CEK. These must run under CEK. *)
+let _jit_is_broken_name n =
+  (* Parser combinators *)
+  n = "parse-bind" || n = "seq" || n = "seq2" || n = "many" || n = "many1"
+  || n = "satisfy" || n = "fmap" || n = "alt" || n = "alt2"
+  || n = "skip-left" || n = "skip-right" || n = "skip-many" || n = "optional"
+  || n = "between" || n = "sep-by" || n = "sep-by1" || n = "parse-char"
+  || n = "parse-string" || n = "lazy-parser" || n = "label"
+  || n = "not-followed-by" || n = "look-ahead"
+  (* Hyperscript orchestrators — call parser combinators *)
+  || n = "hs-tokenize" || n = "hs-parse" || n = "hs-compile"
+  || n = "hs-to-sx" || n = "hs-to-sx-from-source"
+  (* Test orchestration helpers *)
+  || n = "eval-hs" || n = "eval-hs-inner" || n = "eval-hs-with-me"
+  || n = "run-hs-fixture"
+  (* Large top-level functions whose JIT compile exceeds the 5s test
+     deadline — tw-resolve-style, tw-resolve-layout, graphql parse. *)
+  || n = "tw-resolve-style" || n = "tw-resolve-layout"
+  || n = "gql-ws?" || n = "gql-parse-tokens" || n = "gql-execute-operation"
+  (* Hyperscript loop runtime: uses `guard` to catch hs-break/hs-continue
+     exceptions. JIT-compiled guard drops the exception handler such that
+     break propagates out of the click handler instead of exiting the loop.
+     See hs-upstream-repeat/hs-upstream-put tests. *)
+  || n = "hs-repeat-times" || n = "hs-repeat-forever"
+  || n = "hs-repeat-while" || n = "hs-repeat-until"
+  || n = "hs-for-each" || n = "hs-put!"
+
 let jit_compile_lambda (l : lambda) globals =
   let fn_name = match l.l_name with Some n -> n | None -> "<anon>" in
   if !_jit_compiling then (
@@ -944,6 +979,12 @@ let jit_compile_lambda (l : lambda) globals =
     (* &key/:as require complex runtime argument processing that the compiler
        doesn't emit. These functions must run via CEK. *)
     None
+  ) else if l.l_name = None || l.l_closure.Sx_types.parent <> None then (
+    (* Anonymous or nested lambdas: skip JIT. Nested defines get re-created
+       on each outer call, so per-call compile cost is pure overhead. *)
+    None
+  ) else if _jit_is_broken_name fn_name then (
+    None
   ) else
   try
     _jit_compiling := true;