kernel: type predicates + metacircular demo + map/filter/reduce fix [shapes-reflective]

Five type predicates (number?, string?, list?, boolean?, symbol?).
New tests/metacircular.sx: m-eval defined in Kernel walks expressions
itself, recursing on applicative-call args and delegating to host
eval only for operatives and symbol lookup. 14 demo tests.

The demo surfaced a real bug: map/filter/reduce called kernel-combine
on applicative head-vals directly, which re-evaluates already-
evaluated element values; nested-list elements crashed. Fix: extracted
knl-apply-op (unwrap-applicative-or-pass-through) and use it in all
three combinators before kernel-combine. Mirrors apply's approach.

Added knl-apply-op as a proposed entry in the reflective combiner.sx
API. 322 tests total.

lib/kernel/runtime.sx

@@ -534,6 +534,21 @@
 
 (define kernel-not-applicative (knl-unary-app "not" (fn (v) (not v))))
 
+;; Type predicates (Kernel-visible). Note `string?` covers BOTH symbols
+;; and string-literals in our representation (symbols are bare SX
+;; strings); a `kernel-string?` applicative distinguishes the two if
+;; needed.
+(define kernel-number?-applicative
+  (knl-unary-app "number?" (fn (v) (number? v))))
+(define kernel-string?-applicative
+  (knl-unary-app "string?" (fn (v) (string? v))))
+(define kernel-list?-applicative
+  (knl-unary-app "list?" (fn (v) (list? v))))
+(define kernel-boolean?-applicative
+  (knl-unary-app "boolean?" (fn (v) (boolean? v))))
+(define kernel-symbol?-applicative
+  (knl-unary-app "symbol?" (fn (v) (string? v))))
+
 (define kernel-eq?-applicative (knl-bin-app "eq?" (fn (a b) (= a b))))
 
 ;; ── the standard environment ────────────────────────────────────
@@ -546,13 +561,27 @@
 ;; These re-enter the evaluator on each element, so they use the
 ;; with-env applicative constructor.
 
+;; When the combiner is an applicative, we MUST unwrap before calling
+;; — otherwise kernel-combine will re-evaluate the already-evaluated
+;; element values (and crash if an element is itself a list).
+(define knl-apply-op
+  (fn (combiner)
+    (cond
+      ((kernel-applicative? combiner) (kernel-unwrap combiner))
+      (:else combiner))))
+
 (define knl-map-step
   (fn (fn-val xs dyn-env)
+    (let ((op (knl-apply-op fn-val)))
+      (knl-map-walk op xs dyn-env))))
+
+(define knl-map-walk
+  (fn (op xs dyn-env)
     (cond
       ((or (nil? xs) (= (length xs) 0)) (list))
       (:else
-        (cons (kernel-combine fn-val (list (first xs)) dyn-env)
-              (knl-map-step fn-val (rest xs) dyn-env))))))
+        (cons (kernel-combine op (list (first xs)) dyn-env)
+              (knl-map-walk op (rest xs) dyn-env))))))
 
 (define kernel-map-applicative
   (kernel-make-primitive-applicative-with-env
@@ -568,15 +597,18 @@
 
 (define knl-filter-step
   (fn (pred xs dyn-env)
+    (knl-filter-walk (knl-apply-op pred) xs dyn-env)))
+
+(define knl-filter-walk
+  (fn (op xs dyn-env)
     (cond
       ((or (nil? xs) (= (length xs) 0)) (list))
       (:else
-        (let ((keep? (kernel-combine pred (list (first xs)) dyn-env)))
+        (let ((keep? (kernel-combine op (list (first xs)) dyn-env)))
           (cond
             (keep?
-              (cons (first xs)
-                    (knl-filter-step pred (rest xs) dyn-env)))
-            (:else (knl-filter-step pred (rest xs) dyn-env))))))))
+              (cons (first xs) (knl-filter-walk op (rest xs) dyn-env)))
+            (:else (knl-filter-walk op (rest xs) dyn-env))))))))
 
 (define kernel-filter-applicative
   (kernel-make-primitive-applicative-with-env
@@ -592,13 +624,17 @@
 
 (define knl-reduce-step
   (fn (fn-val xs acc dyn-env)
+    (knl-reduce-walk (knl-apply-op fn-val) xs acc dyn-env)))
+
+(define knl-reduce-walk
+  (fn (op xs acc dyn-env)
     (cond
       ((or (nil? xs) (= (length xs) 0)) acc)
       (:else
-        (knl-reduce-step
-          fn-val
+        (knl-reduce-walk
+          op
           (rest xs)
-          (kernel-combine fn-val (list acc (first xs)) dyn-env)
+          (kernel-combine op (list acc (first xs)) dyn-env)
           dyn-env)))))
 
 ;; (apply COMBINER ARGS-LIST) — call COMBINER with the elements of
@@ -861,6 +897,11 @@
       (kernel-env-bind! env "apply"   kernel-apply-applicative)
       (kernel-env-bind! env "append"  kernel-append-applicative)
       (kernel-env-bind! env "reverse" kernel-reverse-applicative)
+      (kernel-env-bind! env "number?"  kernel-number?-applicative)
+      (kernel-env-bind! env "string?"  kernel-string?-applicative)
+      (kernel-env-bind! env "list?"    kernel-list?-applicative)
+      (kernel-env-bind! env "boolean?" kernel-boolean?-applicative)
+      (kernel-env-bind! env "symbol?"  kernel-symbol?-applicative)
       (kernel-env-bind! env "not" kernel-not-applicative)
       (kernel-env-bind! env "make-encapsulation-type"
                             kernel-make-encap-type-applicative)