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/router.sx

@@ -17,7 +17,7 @@
 ;; "/" → ()
 ;; "/docs/" → ("docs")
 
-(define split-path-segments
+(define split-path-segments :effects []
   (fn ((path :as string))
     (let ((trimmed (if (starts-with? path "/") (slice path 1) path)))
       (let ((trimmed2 (if (and (not (empty? trimmed))
@@ -35,7 +35,7 @@
 ;; "/docs/<slug>" → ({"type" "literal" "value" "docs"}
 ;;                   {"type" "param" "value" "slug"})
 
-(define make-route-segment
+(define make-route-segment :effects []
   (fn ((seg :as string))
     (if (and (starts-with? seg "<") (ends-with? seg ">"))
       (let ((param-name (slice seg 1 (- (len seg) 1))))
@@ -48,7 +48,7 @@
         (dict-set! d "value" seg)
         d))))
 
-(define parse-route-pattern
+(define parse-route-pattern :effects []
   (fn ((pattern :as string))
     (let ((segments (split-path-segments pattern)))
       (map make-route-segment segments))))
@@ -59,7 +59,7 @@
 ;; --------------------------------------------------------------------------
 ;; Returns params dict if match, nil if no match.
 
-(define match-route-segments
+(define match-route-segments :effects []
   (fn ((path-segs :as list) (parsed-segs :as list))
     (if (not (= (len path-segs) (len parsed-segs)))
       nil
@@ -87,7 +87,7 @@
 ;; --------------------------------------------------------------------------
 ;; Returns params dict (may be empty for exact matches) or nil.
 
-(define match-route
+(define match-route :effects []
   (fn ((path :as string) (pattern :as string))
     (let ((path-segs (split-path-segments path))
           (parsed-segs (parse-route-pattern pattern)))
@@ -100,7 +100,7 @@
 ;; Each entry: {"pattern" "/docs/<slug>" "parsed" [...] "name" "docs-page" ...}
 ;; Returns matching entry with "params" added, or nil.
 
-(define find-matching-route
+(define find-matching-route :effects []
   (fn ((path :as string) (routes :as list))
     (let ((path-segs (split-path-segments path))
           (result nil))