go: eval.sx — maps + index-assign + 8 tests; word-count e2e [nothing]

Phase 4 cont. Adds map values and index-assignment for both
slices and maps.

Map representation: (list :go-map ENTRIES) where ENTRIES is an
association list of (key value) pairs.

  go-map-get / go-map-set    — primitive lookup + functional-update.
  go-slice-set               — same idea for slices.

go-extract-map-entries reads each :kv element in a composite literal,
evaluating key and value. go-eval-composite dispatches on :ty-map to
build the :go-map value.

go-eval-index extended: when OBJ is a :go-map, look up the key via
go-map-get. Missing keys return nil in v0 (Go's real semantics is
the zero value of the value type — needs runtime type info that this
slice doesn't yet thread through).

go-eval-builtin's len handles :go-map alongside :go-slice and strings.

go-eval-assign-pairs gets a new branch for (:index OBJ IDX) LHS:
  - var-rooted indexing only (a[i] = v / m["k"] = v)
  - slice → go-slice-set then rebind the var
  - map   → go-map-set then rebind the var

**Word-counter via map[string]int works end-to-end:**

  words := []string{"a", "b", "a", "c", "a"}
  counts := map[string]int{}
  for i := 0; i < len(words); i++ {
    counts[words[i]] = counts[words[i]] + 1
  }
  // counts["a"] == 3

Builds on:
  - map composite literal eval
  - map index lookup
  - map index-assign
  - slice indexing
  - len() builtin
  - nil + 1 = 1 (numeric-coercion of missing-key default)

eval 58/58, total 435/435.

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

lib/go/tests/eval.sx

@@ -262,6 +262,60 @@
     (go-env-lookup env "sum"))
   15)
 
+(go-eval-test
+  "map: map[string]int{...} → :go-map"
+  (gtev go-env-empty "map[string]int{\"a\": 1, \"b\": 2}")
+  (list :go-map (list (list "a" 1) (list "b" 2))))
+
+(go-eval-test
+  "map: m[\"a\"] → 1"
+  (let
+    ((env (go-eval-program go-env-empty (list (go-parse "m := map[string]int{\"a\": 1, \"b\": 2}")))))
+    (go-eval env (go-parse "m[\"a\"]")))
+  1)
+
+(go-eval-test
+  "map: missing key → nil (v0 stand-in for zero value)"
+  (let
+    ((env (go-eval-program go-env-empty (list (go-parse "m := map[string]int{\"a\": 1}")))))
+    (go-eval env (go-parse "m[\"missing\"]")))
+  nil)
+
+(go-eval-test
+  "map: len(m) = 2"
+  (let
+    ((env (go-eval-program go-env-builtins (list (go-parse "m := map[string]int{\"a\": 1, \"b\": 2}")))))
+    (go-eval env (go-parse "len(m)")))
+  2)
+
+(go-eval-test
+  "map: index-assign updates existing key"
+  (let
+    ((env (go-eval-program go-env-empty (list (go-parse "m := map[string]int{\"a\": 1}") (go-parse "m[\"a\"] = 99")))))
+    (go-eval env (go-parse "m[\"a\"]")))
+  99)
+
+(go-eval-test
+  "map: index-assign adds new key"
+  (let
+    ((env (go-eval-program go-env-empty (list (go-parse "m := map[string]int{}") (go-parse "m[\"new\"] = 7")))))
+    (go-eval env (go-parse "m[\"new\"]")))
+  7)
+
+(go-eval-test
+  "slice: index-assign a[0] = 99"
+  (let
+    ((env (go-eval-program go-env-empty (list (go-parse "a := []int{10, 20, 30}") (go-parse "a[0] = 99")))))
+    (go-eval env (go-parse "a[0]")))
+  99)
+
+(go-eval-test
+  "map: word count via loop"
+  (let
+    ((env (go-eval-program go-env-builtins (list (go-parse "words := []string{\"a\", \"b\", \"a\", \"c\", \"a\"}") (go-parse "counts := map[string]int{}") (go-parse "for i := 0; i < len(words); i++ { counts[words[i]] = counts[words[i]] + 1 }")))))
+    (go-eval env (go-parse "counts[\"a\"]")))
+  3)
+
 (define
   go-eval-test-summary
   (str "eval " go-eval-test-pass "/" go-eval-test-count))