JIT: restore re-entrancy guards, compile quasiquote inline, closure env merging

Fix infinite recursion in VM JIT: restore sentinel pre-mark in vm_call
and pre-compile loop so recursive compiler functions don't trigger
unbounded compilation cascades. Runtime VM errors fall back to CEK;
compile errors surface visibly (not silently swallowed).

New: compile-quasiquote emits inline code instead of delegating to
qq-expand-runtime. Closure-captured variables merged into VM globals
so compiled closures resolve outer bindings via GLOBAL_GET.

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

spec/compiler.sx

@@ -601,13 +601,79 @@
 
 (define compile-quasiquote
   (fn (em expr scope)
-    "Compile quasiquote — look up qq-expand-runtime in globals and call it.
-     Uses GLOBAL_GET + CALL (not CALL_PRIM) since it's a runtime function."
-    ;; Stack: push fn first, then arg, then CALL 1
-    (let ((name-idx (pool-add (get em "pool") "qq-expand-runtime")))
-      (emit-op em 20) (emit-u16 em name-idx))  ;; GLOBAL_GET fn
-    (emit-const em expr)                         ;; push template
-    (emit-op em 48) (emit-byte em 1)))
+    "Compile quasiquote inline — walks the template at compile time,
+     emitting code that builds the structure at runtime. Unquoted
+     expressions are compiled normally (resolving locals/upvalues),
+     avoiding the qq-expand-runtime env-lookup limitation."
+    (compile-qq-expr em expr scope)))
+
+(define compile-qq-expr
+  (fn (em expr scope)
+    "Compile a quasiquote sub-expression."
+    (if (not (= (type-of expr) "list"))
+      ;; Atom — emit as constant
+      (emit-const em expr)
+      (if (empty? expr)
+        ;; Empty list
+        (do (emit-op em 64) (emit-u16 em 0))  ;; OP_LIST 0
+        (let ((head (first expr)))
+          (if (and (= (type-of head) "symbol")
+                   (= (symbol-name head) "unquote"))
+            ;; (unquote expr) — compile the expression
+            (compile-expr em (nth expr 1) scope false)
+            ;; List — compile elements, handling splice-unquote
+            (compile-qq-list em expr scope)))))))
+
+(define compile-qq-list
+  (fn (em items scope)
+    "Compile a quasiquote list. Handles splice-unquote by building
+     segments and concatenating them."
+    (let ((has-splice (some (fn (item)
+            (and (= (type-of item) "list")
+                 (>= (len item) 2)
+                 (= (type-of (first item)) "symbol")
+                 (= (symbol-name (first item)) "splice-unquote")))
+            items)))
+      (if (not has-splice)
+        ;; No splicing — compile each element, then OP_LIST
+        (do
+          (for-each (fn (item) (compile-qq-expr em item scope)) items)
+          (emit-op em 64) (emit-u16 em (len items)))  ;; OP_LIST N
+        ;; Has splicing — build segments and concat
+        ;; Strategy: accumulate non-spliced items into a pending list,
+        ;; flush as OP_LIST when hitting a splice, concat all segments.
+        (let ((segment-count 0)
+              (pending 0))
+          (for-each
+            (fn (item)
+              (if (and (= (type-of item) "list")
+                       (>= (len item) 2)
+                       (= (type-of (first item)) "symbol")
+                       (= (symbol-name (first item)) "splice-unquote"))
+                ;; Splice-unquote: flush pending, compile spliced expr
+                (do
+                  (when (> pending 0)
+                    (emit-op em 64) (emit-u16 em pending)  ;; OP_LIST for pending
+                    (set! segment-count (+ segment-count 1))
+                    (set! pending 0))
+                  ;; Compile the spliced expression
+                  (compile-expr em (nth item 1) scope false)
+                  (set! segment-count (+ segment-count 1)))
+                ;; Normal element — compile and count as pending
+                (do
+                  (compile-qq-expr em item scope)
+                  (set! pending (+ pending 1)))))
+            items)
+          ;; Flush remaining pending items
+          (when (> pending 0)
+            (emit-op em 64) (emit-u16 em pending)
+            (set! segment-count (+ segment-count 1)))
+          ;; Concat all segments
+          (when (> segment-count 1)
+            (let ((concat-idx (pool-add (get em "pool") "concat")))
+              ;; concat takes N args — call with all segments
+              (emit-op em 52) (emit-u16 em concat-idx)
+              (emit-byte em segment-count))))))))
 
 
 ;; --------------------------------------------------------------------------