apl: bracket indexing A[I] → (I⌷A) (+7 tests, 415/415)

Parser: maybe-bracket helper wraps any value followed by [expr]
into (:dyad (:fn-glyph ⌷) idx val).  Wired into :name and :lparen
branches of collect-segments-loop.

apl-run "(10 20 30)[2]" → 20
apl-run "A ← 100 200 300 ⋄ A[2]" → 200
apl-run "(⍳5)[3] × 7" → 21

Multi-axis A[I;J] deferred — needs semicolon-split parsing.

lib/apl/parser.sx

@@ -206,17 +206,24 @@
                         tokens
                         ni
                         (append acc {:kind "fn" :node fn-node})))))
-                (collect-segments-loop
-                  tokens
-                  (+ i 1)
-                  (append acc {:kind "val" :node (list :name tv)}))))
+                (let
+                  ((br (maybe-bracket (list :name tv) tokens (+ i 1))))
+                  (collect-segments-loop
+                    tokens
+                    (nth br 1)
+                    (append acc {:kind "val" :node (nth br 0)})))))
             ((= tt :lparen)
               (let
                 ((end (find-matching-close tokens (+ i 1) :lparen :rparen)))
                 (let
                   ((inner-tokens (slice tokens (+ i 1) end))
                     (after (+ end 1)))
-                  (collect-segments-loop tokens after (append acc {:kind "val" :node (parse-apl-expr inner-tokens)})))))
+                  (let
+                    ((br (maybe-bracket (parse-apl-expr inner-tokens) tokens after)))
+                    (collect-segments-loop
+                      tokens
+                      (nth br 1)
+                      (append acc {:kind "val" :node (nth br 0)}))))))
             ((= tt :lbrace)
               (let
                 ((end (find-matching-close tokens (+ i 1) :lbrace :rbrace)))
@@ -499,3 +506,23 @@
             (= (len stmt-groups) 1)
             (parse-stmt (first stmt-groups))
             (cons :program (map parse-stmt stmt-groups))))))))
+
+(define
+  maybe-bracket
+  (fn
+    (val-node tokens after)
+    (if
+      (and
+        (< after (len tokens))
+        (= (tok-type (nth tokens after)) :lbracket))
+      (let
+        ((end (find-matching-close tokens (+ after 1) :lbracket :rbracket)))
+        (let
+          ((inner-tokens (slice tokens (+ after 1) end))
+            (next-after (+ end 1)))
+          (let
+            ((idx-expr (parse-apl-expr inner-tokens)))
+            (let
+              ((indexed (list :dyad (list :fn-glyph "⌷") idx-expr val-node)))
+              (maybe-bracket indexed tokens next-after)))))
+      (list val-node after))))