Fix named-let set! scoping + convert test to deftest

Named let's sf-named-let used call-lambda which returns a thunk that
was never trampolined. The body executed in a disconnected env, so
set! couldn't reach outer let bindings. Fixed by using cek-call which
evaluates through the full CEK machine with proper env chain.

Also converted test-named-let-set.sx from assert= (uses broken = for
lists) to deftest/assert-equal (uses deep equal?).

JS standard: 1120/1120, JS full: 1600/1600. Zero failures.

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

spec/evaluator.sx

@@ -544,7 +544,7 @@
         (env-bind! (lambda-closure loop-fn) loop-name loop-fn)
         (let
           ((init-vals (map (fn (e) (trampoline (eval-expr e env))) inits)))
-          (call-lambda loop-fn init-vals env))))))
+          (cek-call loop-fn init-vals))))))
 
 (define
   sf-lambda

spec/tests/test-named-let-set.sx

@@ -1,52 +1,38 @@
-(assert=
-  (let ((x 0)) (let loop () (when (< x 5) (set! x (+ x 1)) (loop))) x)
-  5
-  "set! counter in named let loop")
+(defsuite "named-let-set"
+  (deftest "set! counter in named let loop"
+    (assert-equal 5
+      (let ((x 0)) (let loop () (when (< x 5) (set! x (+ x 1)) (loop))) x)))
 
-(assert=
-  (let
-    ((acc (list)))
-    (let
-      loop
-      ((i 0))
-      (when (< i 3) (set! acc (append acc (list i))) (loop (+ i 1))))
-    acc)
-  (list 0 1 2)
-  "set! list accumulator in named let with param")
+  (deftest "set! list accumulator in named let with param"
+    (assert-equal (list 0 1 2)
+      (let ((acc (list)))
+        (let loop ((i 0))
+          (when (< i 3) (set! acc (append acc (list i))) (loop (+ i 1))))
+        acc)))
 
-(assert=
-  (let
-    ((acc (list)) (i 0))
-    (let loop () (when (< i 3) (append! acc i) (set! i (+ i 1)) (loop)))
-    acc)
-  (list 0 1 2)
-  "append! + set! counter in named let")
+  (deftest "append! + set! counter in named let"
+    (assert-equal (list 0 1 2)
+      (let ((acc (list)) (i 0))
+        (let loop () (when (< i 3) (append! acc i) (set! i (+ i 1)) (loop)))
+        acc)))
 
-(assert=
-  (let
-    ((sum 0))
-    (let
-      loop
-      ((i 1))
-      (when (<= i 10) (set! sum (+ sum i)) (loop (+ i 1))))
-    sum)
-  55
-  "set! sum in named let loop (1..10)")
+  (deftest "set! sum in named let loop (1..10)"
+    (assert-equal 55
+      (let ((sum 0))
+        (let loop ((i 1))
+          (when (<= i 10) (set! sum (+ sum i)) (loop (+ i 1))))
+        sum)))
 
-(assert=
-  (let
-    ((result ""))
-    (let
-      loop
-      ((i 0))
-      (when (< i 3) (set! result (str result (str i))) (loop (+ i 1))))
-    result)
-  "012"
-  "set! string accumulator in named let")
+  (deftest "set! string accumulator in named let"
+    (assert-equal "012"
+      (let ((result ""))
+        (let loop ((i 0))
+          (when (< i 3) (set! result (str result (str i))) (loop (+ i 1))))
+        result)))
 
-(assert= (let ((x 0)) (set! x 42) x) 42 "set! in plain let (baseline)")
+  (deftest "set! in plain let (baseline)"
+    (assert-equal 42 (let ((x 0)) (set! x 42) x)))
 
-(assert=
-  (let loop ((i 0) (acc 0)) (if (< i 5) (loop (+ i 1) (+ acc i)) acc))
-  10
-  "named let without set! (baseline)")
+  (deftest "named let without set! (baseline)"
+    (assert-equal 10
+      (let loop ((i 0) (acc 0)) (if (< i 5) (loop (+ i 1) (+ acc i)) acc)))))