CEK-native higher-order forms: map, filter, reduce, some, every?, for-each

Higher-order forms now step element-by-element through the CEK machine
using dedicated frames instead of delegating to tree-walk ho-map etc.
Each callback invocation goes through continue-with-call, so deref-as-shift
works inside map/filter/reduce callbacks in reactive island contexts.

- cek.sx: rewrite step-ho-* to use CEK frames, add frame handlers in
  step-continue for map, filter, reduce, for-each, some, every
- frames.sx: add SomeFrame, EveryFrame, MapIndexedFrame
- test-cek-reactive.sx: add 10 tests for CEK-native HO forms

89 tests pass (20 signal + 43 CEK + 26 CEK reactive).

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

shared/sx/ref/test-cek-reactive.sx

@@ -209,3 +209,71 @@
         (reset! s 3)))
       ;; batch should coalesce — effect runs once, not three times
       (assert-equal 2 (deref count)))))
+
+
+;; --------------------------------------------------------------------------
+;; CEK-native higher-order forms
+;; --------------------------------------------------------------------------
+
+(defsuite "CEK higher-order forms"
+  (deftest "map through CEK"
+    (let ((result (eval-expr-cek
+                    (sx-parse-one "(map (fn (x) (* x 2)) (list 1 2 3))")
+                    (test-env))))
+      (assert-equal (list 2 4 6) result)))
+
+  (deftest "map-indexed through CEK"
+    (let ((result (eval-expr-cek
+                    (sx-parse-one "(map-indexed (fn (i x) (+ i x)) (list 10 20 30))")
+                    (test-env))))
+      (assert-equal (list 10 21 32) result)))
+
+  (deftest "filter through CEK"
+    (let ((result (eval-expr-cek
+                    (sx-parse-one "(filter (fn (x) (> x 2)) (list 1 2 3 4 5))")
+                    (test-env))))
+      (assert-equal (list 3 4 5) result)))
+
+  (deftest "reduce through CEK"
+    (let ((result (eval-expr-cek
+                    (sx-parse-one "(reduce (fn (acc x) (+ acc x)) 0 (list 1 2 3))")
+                    (test-env))))
+      (assert-equal 6 result)))
+
+  (deftest "some through CEK"
+    (let ((result (eval-expr-cek
+                    (sx-parse-one "(some (fn (x) (> x 3)) (list 1 2 3 4 5))")
+                    (test-env))))
+      (assert-true result)))
+
+  (deftest "some returns false when none match"
+    (let ((result (eval-expr-cek
+                    (sx-parse-one "(some (fn (x) (> x 10)) (list 1 2 3))")
+                    (test-env))))
+      (assert-false result)))
+
+  (deftest "every? through CEK"
+    (let ((result (eval-expr-cek
+                    (sx-parse-one "(every? (fn (x) (> x 0)) (list 1 2 3))")
+                    (test-env))))
+      (assert-true result)))
+
+  (deftest "every? returns false on first falsy"
+    (let ((result (eval-expr-cek
+                    (sx-parse-one "(every? (fn (x) (> x 2)) (list 1 2 3))")
+                    (test-env))))
+      (assert-false result)))
+
+  (deftest "for-each through CEK"
+    (let ((log (list)))
+      (env-set! (test-env) "test-log" log)
+      (eval-expr-cek
+        (sx-parse-one "(for-each (fn (x) (append! test-log x)) (list 1 2 3))")
+        (test-env))
+      (assert-equal (list 1 2 3) log)))
+
+  (deftest "map on empty list"
+    (let ((result (eval-expr-cek
+                    (sx-parse-one "(map (fn (x) x) (list))")
+                    (test-env))))
+      (assert-equal (list) result))))