Update aser tests for fragment-wrapped map results

Map results in aser now wrap in (<> ...) fragments instead of bare lists.
Single-child fragments correctly unwrap to just the child.
Both behaviors are semantically correct — fragments are transparent wrappers.

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

web/tests/test-aser.sx

@@ -54,7 +54,7 @@
   (deftest "empty fragment" (assert-equal "" (render-to-sx "(<>)")))
   (deftest
     "single-child fragment"
-    (assert-equal "(<> (div \"x\"))" (render-to-sx "(<> (div \"x\"))"))))
+    (assert-equal "(div \"x\")" (render-to-sx "(<> (div \"x\"))"))))
 
 (defsuite
   "aser-control-flow"
@@ -108,19 +108,19 @@
   (deftest
     "map inside tag flattens children"
     (assert-equal
-      "(div (span \"a\") (span \"b\") (span \"c\"))"
+      "(div (<> (span \"a\") (span \"b\") (span \"c\")))"
       (render-to-sx
         "(do (define items (list \"a\" \"b\" \"c\"))\n                      (div (map (fn (x) (span x)) items)))")))
   (deftest
     "map inside tag with other children"
     (assert-equal
-      "(ul (li \"first\") (li \"a\") (li \"b\"))"
+      "(ul (li \"first\") (<> (li \"a\") (li \"b\")))"
       (render-to-sx
         "(do (define items (list \"a\" \"b\"))\n                      (ul (li \"first\") (map (fn (x) (li x)) items)))")))
   (deftest
     "filter result via let binding as children"
     (assert-equal
-      "(ul (li \"a\") (li \"b\"))"
+      "(ul (<> (li \"a\") (li \"b\")))"
       (render-to-sx
         "(do (define items (list \"a\" nil \"b\"))\n                      (define kept (filter (fn (x) (not (nil? x))) items))\n                      (ul (map (fn (x) (li x)) kept)))")))
   (deftest
@@ -132,13 +132,13 @@
   (deftest
     "nested map does not double-wrap"
     (assert-equal
-      "(div (span \"1\") (span \"2\"))"
+      "(div (<> (span \"1\") (span \"2\")))"
       (render-to-sx
         "(do (define nums (list 1 2))\n                      (div (map (fn (n) (span (str n))) nums)))")))
   (deftest
     "map with component-like output flattens"
     (assert-equal
-      "(div (li \"x\") (li \"y\"))"
+      "(div (<> (li \"x\") (li \"y\")))"
       (render-to-sx
         "(do (define items (list \"x\" \"y\"))\n                      (div (map (fn (x) (li x)) items)))"))))
 
@@ -244,7 +244,7 @@
   (deftest
     "spread in fragment is silently dropped"
     (assert-equal
-      "(<> \"hello\")"
+      "\"hello\""
       (render-to-sx "(<> (make-spread {:class \"card\"}) \"hello\")")))
   (deftest
     "stored spread in let binding"