Unify scoped effects: scope as general primitive, provide as sugar

- Add `scope` special form to eval.sx: (scope name body...) or
  (scope name :value v body...) — general dynamic scope primitive
- `provide` becomes sugar: (provide name value body...) calls scope
- Rename provide-push!/provide-pop! to scope-push!/scope-pop! throughout
  all adapters (async, dom, html, sx) and platform implementations
- Update boundary.sx: Tier 5 now "Scoped effects" with scope-push!/
  scope-pop! as primary, provide-push!/provide-pop! as aliases
- Add scope form handling to async adapter and aser wire format
- Update sx-browser.js, sx_ref.py (bootstrapped output)
- Add scopes.sx docs page, update provide/spreads/demo docs
- Update nav-data, page-functions, docs page definitions

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

shared/sx/ref/adapter-sx.sx

@@ -144,7 +144,7 @@
           (skip false)
           (i 0))
       ;; Provide scope for spread emit!
-      (provide-push! "element-attrs" nil)
+      (scope-push! "element-attrs" nil)
       (for-each
         (fn (arg)
           (if skip
@@ -179,7 +179,7 @@
                 (append! attr-parts (serialize v))))
             (keys spread-dict)))
         (emitted "element-attrs"))
-      (provide-pop! "element-attrs")
+      (scope-pop! "element-attrs")
       (let ((parts (concat (list name) attr-parts child-parts)))
         (str "(" (join " " parts) ")")))))
 
@@ -195,7 +195,7 @@
         "defhandler" "defpage" "defquery" "defaction" "defrelation"
         "begin" "do" "quote" "quasiquote"
         "->" "set!" "letrec" "dynamic-wind" "defisland"
-        "deftype" "defeffect" "provide"))
+        "deftype" "defeffect" "scope" "provide"))
 
 (define HO_FORM_NAMES
   (list "map" "map-indexed" "filter" "reduce"
@@ -333,15 +333,35 @@
             (= name "deftype") (= name "defeffect"))
           (do (trampoline (eval-expr expr env)) nil)
 
-        ;; provide — render-time dynamic scope
+        ;; scope — unified render-time dynamic scope
+        (= name "scope")
+          (let ((scope-name (trampoline (eval-expr (first args) env)))
+                (rest-args (rest args))
+                (scope-val nil)
+                (body-args nil))
+            ;; Check for :value keyword
+            (if (and (>= (len rest-args) 2)
+                     (= (type-of (first rest-args)) "keyword")
+                     (= (keyword-name (first rest-args)) "value"))
+              (do (set! scope-val (trampoline (eval-expr (nth rest-args 1) env)))
+                  (set! body-args (slice rest-args 2)))
+              (set! body-args rest-args))
+            (scope-push! scope-name scope-val)
+            (let ((result nil))
+              (for-each (fn (body) (set! result (aser body env)))
+                        body-args)
+              (scope-pop! scope-name)
+              result))
+
+        ;; provide — sugar for scope with value
         (= name "provide")
           (let ((prov-name (trampoline (eval-expr (first args) env)))
                 (prov-val (trampoline (eval-expr (nth args 1) env)))
                 (result nil))
-            (provide-push! prov-name prov-val)
+            (scope-push! prov-name prov-val)
             (for-each (fn (body) (set! result (aser body env)))
                       (slice args 2))
-            (provide-pop! prov-name)
+            (scope-pop! prov-name)
             result)
 
         ;; Everything else — evaluate normally