VM: VmClosure value type + iterative run loop + define hoisting + SSR fixes

Core VM changes:
- Add VmClosure value variant — inner closures created by OP_CLOSURE are
  first-class VM values, not NativeFn wrappers around call_closure
- Convert `run` from recursive to while-loop — zero OCaml stack growth,
  true TCO for VmClosure tail calls
- vm_call handles VmClosure by pushing frame on current VM (no new VM
  allocation per call)
- Forward ref _vm_call_closure_ref for cross-boundary calls (CEK/primitives)

Compiler (spec/compiler.sx):
- Define hoisting in compile-begin: pre-allocate local slots for all
  define forms before compiling any values. Fixes forward references
  between inner functions (e.g. read-expr referencing skip-ws in sx-parse)
- scope-define-local made idempotent (skip if slot already exists)

Server (sx_server.ml):
- JIT fail-once sentinel: mark l_compiled as failed after first VM runtime
  error. Eliminates thousands of retry attempts per page render.
- HTML tag bindings: register all HTML tags as pass-through NativeFns so
  eval-expr can handle (div ...) etc. in island component bodies.
- Log VM FAIL errors with function name before disabling JIT.

SSR fixes:
- adapter-html.sx letrec handler: evaluate bindings in proper letrec scope
  (pre-bind nil, then evaluate), render body with render-to-html instead of
  eval-expr. Fixes island SSR for components using letrec.
- Add `init` primitive to OCaml kernel (all-but-last of list).
- VmClosure handling in sx_runtime.ml sx_call dispatch.

Tests: 971/971 OCaml (+19 new), 0 failures.

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

spec/compiler.sx

@@ -50,12 +50,17 @@
 
 (define scope-define-local
   (fn (scope name)
-    "Add a local variable, return its slot index."
-    (let ((slot (get scope "next-slot")))
-      (append! (get scope "locals")
-        {:name name :slot slot :mutable false})
-      (dict-set! scope "next-slot" (+ slot 1))
-      slot)))
+    "Add a local variable, return its slot index.
+     Idempotent: if name already has a slot, return it."
+    (let ((existing (first (filter (fn (l) (= (get l "name") name))
+                                   (get scope "locals")))))
+      (if existing
+        (get existing "slot")
+        (let ((slot (get scope "next-slot")))
+          (append! (get scope "locals")
+            {:name name :slot slot :mutable false})
+          (dict-set! scope "next-slot" (+ slot 1))
+          slot)))))
 
 (define scope-resolve
   (fn (scope name)
@@ -354,6 +359,22 @@
 
 (define compile-begin
   (fn (em exprs scope tail?)
+    ;; Hoist: pre-allocate local slots for all define forms in this block.
+    ;; Enables forward references between inner functions (e.g. sx-parse).
+    ;; Only inside function bodies (scope has parent), not at top level.
+    (when (and (not (empty? exprs)) (not (nil? (get scope "parent"))))
+      (for-each (fn (expr)
+        (when (and (= (type-of expr) "list")
+                   (>= (len expr) 2)
+                   (= (type-of (first expr)) "symbol")
+                   (= (symbol-name (first expr)) "define"))
+          (let ((name-expr (nth expr 1))
+                (name (if (= (type-of name-expr) "symbol")
+                        (symbol-name name-expr)
+                        name-expr)))
+            (scope-define-local scope name))))
+        exprs))
+    ;; Compile expressions
     (if (empty? exprs)
       (emit-op em 2)  ;; OP_NIL
       (if (= (len exprs) 1)
@@ -483,11 +504,22 @@
                                    (skip-annotations (rest (rest items)))
                                    (first items))))))
                        (skip-annotations rest-args))
-                     (first rest-args))))
-          (name-idx (pool-add (get em "pool") name)))
-      (compile-expr em value scope false)
-      (emit-op em 128)  ;; OP_DEFINE
-      (emit-u16 em name-idx))))
+                     (first rest-args)))))
+      ;; Inside a function body, define creates a LOCAL binding.
+      ;; At top level (no enclosing function scope), define creates a global.
+      ;; Local binding prevents recursive calls from overwriting
+      ;; each other's defines in the flat globals hashtable.
+      (if (not (nil? (get scope "parent")))
+          ;; Local define — allocate slot, compile value, set local
+          (let ((slot (scope-define-local scope name)))
+            (compile-expr em value scope false)
+            (emit-op em 17)  ;; OP_LOCAL_SET
+            (emit-byte em slot))
+          ;; Top-level define — global
+          (let ((name-idx (pool-add (get em "pool") name)))
+            (compile-expr em value scope false)
+            (emit-op em 128)  ;; OP_DEFINE
+            (emit-u16 em name-idx))))))
 
 
 (define compile-set