Fix process-bindings scope loss and async-invoke arity, bootstrap async adapter

Two bugs fixed:
1. process-bindings used merge(env) which returns {} for Env objects
   (Env is not a dict subclass). Changed to env-extend in render.sx
   and adapter-async.sx. This caused "Undefined symbol: theme" etc.
2. async-aser-eval-call passed evaled-args list to async-invoke(&rest),
   double-wrapping it. Changed to inline apply + coroutine check.

Also: bootstrap define-async into sx_ref.py (Phase 6), replace ~1000 LOC
hand-written async_eval_ref.py with 24-line thin re-export shim.

Test runner now uses Env (not flat dict) for render envs to catch scope bugs.
8 new regression tests (4 scope chain, 2 native callable arity, 2 render).

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

shared/sx/ref/test-aser.sx

@@ -119,6 +119,19 @@
     (assert-equal "(p \"hello\")"
       (render-sx "(let ((x \"hello\")) (p x))")))
 
+  (deftest "let preserves outer scope bindings"
+    ;; Regression: process-bindings must preserve parent env scope chain.
+    ;; Using merge() instead of env-extend loses parent scope items.
+    (assert-equal "(p \"outer\")"
+      (render-sx "(do (define theme \"outer\") (let ((x 1)) (p theme)))")))
+
+  (deftest "nested let preserves outer scope"
+    (assert-equal "(div (span \"hello\") (span \"world\"))"
+      (render-sx "(do (define a \"hello\")
+                      (define b \"world\")
+                      (div (let ((x 1)) (span a))
+                           (let ((y 2)) (span b))))")))
+
   (deftest "begin serializes last"
     (assert-equal "(p \"last\")"
       (render-sx "(begin (p \"first\") (p \"last\"))"))))
@@ -213,6 +226,17 @@
     (assert-equal "10"
       (render-sx "(do (define double (fn (x) (* x 2))) (double 5))")))
 
+  (deftest "native callable with multiple args"
+    ;; Regression: async-aser-eval-call passed evaled-args list to
+    ;; async-invoke (&rest), wrapping it in another list. apply(f, [list])
+    ;; calls f(list) instead of f(*list).
+    (assert-equal "3"
+      (render-sx "(do (define my-add +) (my-add 1 2))")))
+
+  (deftest "native callable with two args via alias"
+    (assert-equal "hello world"
+      (render-sx "(do (define my-join str) (my-join \"hello\" \" world\"))")))
+
   (deftest "higher-order: map returns list"
     (let ((result (render-sx "(map (fn (x) (+ x 1)) (list 1 2 3))")))
       ;; map at top level returns a list, not serialized tags