Add :effects annotations to all spec files and update bootstrappers

Bootstrappers (bootstrap_py.py, js.sx) now skip :effects keyword in
define forms, enabling effect annotations throughout the spec without
changing generated output.

Annotated 180+ functions across 14 spec files:
- signals.sx: signal/deref [] pure, reset!/swap!/effect/batch [mutation]
- engine.sx: parse-* [] pure, morph-*/swap-* [mutation io]
- orchestration.sx: all [mutation io] (browser event binding)
- adapter-html.sx: render-* [render]
- adapter-dom.sx: render-* [render], reactive-* [render mutation]
- adapter-sx.sx: aser-* [render]
- adapter-async.sx: async-render-*/async-aser-* [render io]
- parser.sx: all [] pure
- render.sx: predicates [] pure, process-bindings [mutation]
- boot.sx: all [mutation io] (browser init)
- deps.sx: scan-*/transitive-* [] pure, compute-all-* [mutation]
- router.sx: all [] pure (URL matching)

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

shared/sx/ref/deps.sx

@@ -31,14 +31,14 @@
 ;; Walks all branches of control flow (if/when/cond/case) to find
 ;; every component that *could* be rendered.
 
-(define scan-refs
+(define scan-refs :effects []
   (fn (node)
     (let ((refs (list)))
       (scan-refs-walk node refs)
       refs)))
 
 
-(define scan-refs-walk
+(define scan-refs-walk :effects []
   (fn (node (refs :as list))
     (cond
       ;; Symbol starting with ~ → component reference
@@ -67,7 +67,7 @@
 ;; Given a component name and an environment, compute all components
 ;; that it can transitively render.  Handles cycles via seen-set.
 
-(define transitive-deps-walk
+(define transitive-deps-walk :effects []
   (fn ((n :as string) (seen :as list) (env :as dict))
     (when (not (contains? seen n))
       (append! seen n)
@@ -82,7 +82,7 @@
           :else nil)))))
 
 
-(define transitive-deps
+(define transitive-deps :effects []
   (fn ((name :as string) (env :as dict))
     (let ((seen (list))
           (key (if (starts-with? name "~") name (str "~" name))))
@@ -100,7 +100,7 @@
 ;;   (env-components env) → list of component names in env
 ;;   (component-set-deps! comp deps) → store deps on component
 
-(define compute-all-deps
+(define compute-all-deps :effects [mutation]
   (fn ((env :as dict))
     (for-each
       (fn ((name :as string))
@@ -119,7 +119,7 @@
 ;; Platform interface:
 ;;   (regex-find-all pattern source) → list of matched group strings
 
-(define scan-components-from-source
+(define scan-components-from-source :effects []
   (fn ((source :as string))
     (let ((matches (regex-find-all "\\(~([a-zA-Z_][a-zA-Z0-9_\\-]*)" source)))
       (map (fn ((m :as string)) (str "~" m)) matches))))
@@ -131,7 +131,7 @@
 ;; Scans page source for direct component references, then computes
 ;; the transitive closure.  Returns list of ~names.
 
-(define components-needed
+(define components-needed :effects []
   (fn ((page-source :as string) (env :as dict))
     (let ((direct (scan-components-from-source page-source))
           (all-needed (list)))
@@ -165,7 +165,7 @@
 ;;
 ;; This replaces the "send everything" approach with per-page bundles.
 
-(define page-component-bundle
+(define page-component-bundle :effects []
   (fn ((page-source :as string) (env :as dict))
     (components-needed page-source env)))
 
@@ -180,7 +180,7 @@
 ;;   (component-css-classes c) → set/list of class strings
 ;;   (scan-css-classes source) → set/list of class strings from source
 
-(define page-css-classes
+(define page-css-classes :effects []
   (fn ((page-source :as string) (env :as dict))
     (let ((needed (components-needed page-source env))
           (classes (list)))
@@ -218,7 +218,7 @@
 ;;   (component-io-refs c)        → cached IO ref list (may be empty)
 ;;   (component-set-io-refs! c r) → cache IO refs on component
 
-(define scan-io-refs-walk
+(define scan-io-refs-walk :effects []
   (fn (node (io-names :as list) (refs :as list))
     (cond
       ;; Symbol → check if name is in the IO set
@@ -241,7 +241,7 @@
       :else nil)))
 
 
-(define scan-io-refs
+(define scan-io-refs :effects []
   (fn (node (io-names :as list))
     (let ((refs (list)))
       (scan-io-refs-walk node io-names refs)
@@ -252,7 +252,7 @@
 ;; 9. Transitive IO refs — follow component deps and union IO refs
 ;; --------------------------------------------------------------------------
 
-(define transitive-io-refs-walk
+(define transitive-io-refs-walk :effects []
   (fn ((n :as string) (seen :as list) (all-refs :as list) (env :as dict) (io-names :as list))
     (when (not (contains? seen n))
       (append! seen n)
@@ -285,7 +285,7 @@
           :else nil)))))
 
 
-(define transitive-io-refs
+(define transitive-io-refs :effects []
   (fn ((name :as string) (env :as dict) (io-names :as list))
     (let ((all-refs (list))
           (seen (list))
@@ -298,7 +298,7 @@
 ;; 10. Compute IO refs for all components in an environment
 ;; --------------------------------------------------------------------------
 
-(define compute-all-io-refs
+(define compute-all-io-refs :effects [mutation]
   (fn ((env :as dict) (io-names :as list))
     (for-each
       (fn ((name :as string))
@@ -308,7 +308,7 @@
       (env-components env))))
 
 
-(define component-io-refs-cached
+(define component-io-refs-cached :effects []
   (fn ((name :as string) (env :as dict) (io-names :as list))
     (let ((key (if (starts-with? name "~") name (str "~" name))))
       (let ((val (env-get env key)))
@@ -319,7 +319,7 @@
           ;; Fallback: not yet cached (shouldn't happen after compute-all-io-refs)
           (transitive-io-refs name env io-names))))))
 
-(define component-pure?
+(define component-pure? :effects []
   (fn ((name :as string) (env :as dict) (io-names :as list))
     (let ((key (if (starts-with? name "~") name (str "~" name))))
       (let ((val (env-get env key)))
@@ -343,7 +343,7 @@
 ;;
 ;; Returns: "server" | "client"
 
-(define render-target
+(define render-target :effects []
   (fn ((name :as string) (env :as dict) (io-names :as list))
     (let ((key (if (starts-with? name "~") name (str "~" name))))
       (let ((val (env-get env key)))
@@ -372,7 +372,7 @@
 ;; The async evaluator and client router both use it to make decisions
 ;; without recomputing at every request.
 
-(define page-render-plan
+(define page-render-plan :effects []
   (fn ((page-source :as string) (env :as dict) (io-names :as list))
     (let ((needed (components-needed page-source env))
           (comp-targets (dict))
@@ -450,7 +450,7 @@
 ;; --------------------------------------------------------------------------
 ;; Moved from platform to spec: pure logic using type predicates.
 
-(define env-components
+(define env-components :effects []
   (fn ((env :as dict))
     (filter
       (fn ((k :as string))