Remove invoke from platform interfaces, add cek-call integration tests

- platform_js.py: remove invoke function definition and PRIMITIVES
  registration, switch domListen handler wrapping to cek-call
- platform_py.py: remove invoke function definition
- run_signal_tests.py: remove invoke patch, use cek_call in batch wrapper
- run_cek_reactive_tests.py: remove invoke, fix primitive lookup to use
  two-level is_primitive/get_primitive, increase recursion limit for
  interpreted CEK evaluation
- test-cek-reactive.sx: add 7 new tests covering cek-call dispatch with
  computed, effect, cleanup, batch coalescing

All 79 tests pass (20 signal + 43 CEK + 16 CEK reactive).

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

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

@@ -152,3 +152,60 @@
       ;; Change signal — no update should fire
       (reset! s 999)
       (assert-equal 0 (len update-calls)))))
+
+
+;; --------------------------------------------------------------------------
+;; cek-call integration — computed/effect use cek-call dispatch
+;; --------------------------------------------------------------------------
+
+(defsuite "cek-call dispatch"
+  (deftest "cek-call invokes native function"
+    (let ((log (list)))
+      (cek-call (fn (x) (append! log x)) (list 42))
+      (assert-equal (list 42) log)))
+
+  (deftest "cek-call invokes zero-arg lambda"
+    (let ((result (cek-call (fn () (+ 1 2)) nil)))
+      (assert-equal 3 result)))
+
+  (deftest "cek-call with nil function returns nil"
+    (assert-nil (cek-call nil nil)))
+
+  (deftest "computed tracks deps via cek-call"
+    (let ((s (signal 10)))
+      (let ((c (computed (fn () (* 2 (deref s))))))
+        (assert-equal 20 (deref c))
+        (reset! s 5)
+        (assert-equal 10 (deref c)))))
+
+  (deftest "effect runs and re-runs via cek-call"
+    (let ((s (signal "a"))
+          (log (list)))
+      (effect (fn () (append! log (deref s))))
+      (assert-equal (list "a") log)
+      (reset! s "b")
+      (assert-equal (list "a" "b") log)))
+
+  (deftest "effect cleanup runs on re-trigger"
+    (let ((s (signal 0))
+          (log (list)))
+      (effect (fn ()
+        (let ((val (deref s)))
+          (append! log (str "run:" val))
+          ;; Return cleanup function
+          (fn () (append! log (str "clean:" val))))))
+      (assert-equal (list "run:0") log)
+      (reset! s 1)
+      (assert-equal (list "run:0" "clean:0" "run:1") log)))
+
+  (deftest "batch coalesces via cek-call"
+    (let ((s (signal 0))
+          (count (signal 0)))
+      (effect (fn () (do (deref s) (swap! count inc))))
+      (assert-equal 1 (deref count))
+      (batch (fn ()
+        (reset! s 1)
+        (reset! s 2)
+        (reset! s 3)))
+      ;; batch should coalesce — effect runs once, not three times
+      (assert-equal 2 (deref count)))))