Step 10c: desugared reactive pattern tests (8 new)

Prove that provide/context/bind/peek replace signal/deref/computed
for common reactive patterns:
- counter, toggle (provide! replaces reset!/swap!)
- derived values (bind replaces computed)
- re-evaluation (bind replaces effect)
- read-modify-write (peek + provide! replaces swap!)
- nested state (nested provide replaces multiple signals)
- batch coalescing with desugared pattern

2776/2776 OCaml tests pass.

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

spec/tests/test-unified-reactive.sx

@@ -492,6 +492,65 @@
 ;; --------------------------------------------------------------------------
 ;; edge cases
 ;; --------------------------------------------------------------------------
+(defsuite
+  "desugared-reactive"
+  (deftest
+    "counter without signals"
+    (provide
+      :count 0
+      (provide! :count (+ 1 (context :count)))
+      (assert-equal 1 (context :count))))
+  (deftest
+    "toggle without signals"
+    (provide
+      :on false
+      (provide! :on (not (peek :on)))
+      (assert-equal true (context :on))))
+  (deftest
+    "derived value via bind replaces computed"
+    (provide :x 3 (assert-equal 6 (bind (* 2 (context :x))))))
+  (deftest
+    "bind re-eval replaces computed+effect"
+    (provide
+      :x 1
+      (let
+        ((log (signal (list))))
+        (bind
+          (do (swap! log (fn (l) (append l (list (context :x))))) nil))
+        (assert-equal (list 1) (deref log))
+        (provide! :x 2)
+        (assert-equal (list 1 2) (deref log)))))
+  (deftest
+    "read-modify-write with peek"
+    (provide
+      :items (list "a" "b")
+      (provide! :items (append (peek :items) (list "c")))
+      (assert-equal (list "a" "b" "c") (context :items))))
+  (deftest
+    "nested provide replaces multiple signals"
+    (provide
+      :x 1
+      (provide :y 2 (assert-equal 3 (+ (context :x) (context :y))))))
+  (deftest
+    "provide! with bind replaces swap!+computed"
+    (provide
+      :count 0
+      (let
+        ((doubled (bind (* 2 (context :count)))))
+        (assert-equal 0 doubled)
+        (provide! :count 5)
+        (assert-equal 0 doubled))))
+  (deftest
+    "batch works with desugared pattern"
+    (provide
+      :x 0
+      (let
+        ((calls (signal 0)))
+        (bind (do (swap! calls (fn (n) (+ n 1))) (context :x) nil))
+        (assert-equal 1 (deref calls))
+        (batch (fn () (provide! :x 1) (provide! :x 2) (provide! :x 3)))
+        (assert-equal 2 (deref calls))))))
+
 (defsuite
   "unified-edge-cases"
   (deftest