feat(types): Dict + Set string-keyed containers (#54)

Types phase 4 — containers. A splice-on-demand open-addressing hash table
(runtime/native/dict.ludic, FNV-1a, linear probing, tombstones, grow at 0.7)
behind two namespaces:

- Dict.* — string -> int map: new/set/get/get_or/has/remove/size/clear/keys.
  Resource counts, id/name registries. O(1) average vs a linear list scan.
- Set.* — set of strings: new/add/has/remove/size/clear/members. Tags,
  unlocked achievements, visited tiles. Shares the same table.

Values are int (also an entity handle / small id); Value.* covers richer
maps. [T; N] inline fixed arrays remain future work — typed buffers and []T
slices already cover heap-backed arrays.

Wired: parser splice trigger (g_uses_dict), emit_call dispatch, reseeded seed,
a self-asserting example (examples/library/containers.ludic + feat_case), and
per-symbol docs + inventory. All suites green incl. golden renders byte-
identical and the bootstrap fixpoint.

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

docs/language/dict/_section.md

@@ -0,0 +1,7 @@
+---
+id: dict
+title: Dict
+order: 12
+---
+
+A hash map from string keys to <code>int</code> values — the everyday lookup a game needs, like resource counts or an id registry by name. A <code>Dict</code> is backed by an open-addressing hash table (FNV-1a, linear probing, tombstone deletes, growing at load factor 0.7), so <code>get</code>/<code>set</code>/<code>has</code> are O(1) on average rather than the linear scan a list would give. Create one with <code>Dict.new</code>, then <code>set</code> / <code>get</code> / <code>get_or</code> / <code>has</code> / <code>remove</code> / <code>size</code> / <code>clear</code> / <code>keys</code>. Values are <code>int</code> (which also holds an <code>entity</code> or any small id); for richer values use the <code>Value.*</code> tree. Arguments are positional. The runtime is spliced in only when a program mentions <code>Dict.*</code> (or <code>Set.*</code>).

docs/language/dict/dict-clear.md

@@ -0,0 +1,22 @@
+---
+id: dict-clear
+name: Dict.clear
+category: dict
+kind: namespace-method
+tokens: Dict.clear
+sig: Dict.clear(d)
+tip: Remove every key.
+order: 7
+ns: Dict
+member: clear
+---
+
+Empties the map, removing every key while keeping its allocated capacity.
+
+```ludic
+program Demo {
+  handler Step phase Update {
+    Dict.clear(bank)
+  }
+}
+```

docs/language/dict/dict-get.md

@@ -0,0 +1,22 @@
+---
+id: dict-get
+name: Dict.get
+category: dict
+kind: namespace-method
+tokens: Dict.get
+sig: Dict.get(d, key) -> int
+tip: Look up a key (0 if absent).
+order: 2
+ns: Dict
+member: get
+---
+
+Returns the value stored for <code>key</code>, or <code>0</code> when the key is absent. Use <code>Dict.get_or</code> when <code>0</code> is a meaningful stored value.
+
+```ludic
+program Demo {
+  handler Step phase Update {
+    let gold = Dict.get(bank, "gold")
+  }
+}
+```

docs/language/dict/dict-get_or.md

@@ -0,0 +1,22 @@
+---
+id: dict-get_or
+name: Dict.get_or
+category: dict
+kind: namespace-method
+tokens: Dict.get_or
+sig: Dict.get_or(d, key, fallback) -> int
+tip: Look up a key with an explicit default.
+order: 3
+ns: Dict
+member: get_or
+---
+
+Returns the value for <code>key</code>, or <code>fallback</code> when the key is absent — the unambiguous lookup when <code>0</code> could be a real value.
+
+```ludic
+program Demo {
+  handler Step phase Update {
+    let n = Dict.get_or(bank, "stone", 0 - 1)
+  }
+}
+```

docs/language/dict/dict-has.md

@@ -0,0 +1,22 @@
+---
+id: dict-has
+name: Dict.has
+category: dict
+kind: namespace-method
+tokens: Dict.has
+sig: Dict.has(d, key) -> bool
+tip: Is a key present?
+order: 4
+ns: Dict
+member: has
+---
+
+Returns true when <code>key</code> is present in the map.
+
+```ludic
+program Demo {
+  handler Step phase Update {
+    if Dict.has(bank, "gold") { spend() }
+  }
+}
+```

docs/language/dict/dict-keys.md

@@ -0,0 +1,22 @@
+---
+id: dict-keys
+name: Dict.keys
+category: dict
+kind: namespace-method
+tokens: Dict.keys
+sig: Dict.keys(d) -> []pointer
+tip: Every key, as a slice of strings.
+order: 8
+ns: Dict
+member: keys
+---
+
+Returns every live key as a slice of strings, in unspecified order — iterate it with <code>len</code> and indexing to walk the whole map.
+
+```ludic
+program Demo {
+  handler Step phase Update {
+    let names = Dict.keys(bank)
+  }
+}
+```

docs/language/dict/dict-new.md

@@ -0,0 +1,22 @@
+---
+id: dict-new
+name: Dict.new
+category: dict
+kind: namespace-method
+tokens: Dict.new
+sig: Dict.new() -> Dict
+tip: Create an empty string-keyed map.
+order: 0
+ns: Dict
+member: new
+---
+
+Creates an empty <code>Dict</code> mapping string keys to <code>int</code> values. Fill it with <code>Dict.set</code> and read it back with <code>Dict.get</code>.
+
+```ludic
+program Demo {
+  handler Step phase Update {
+    let bank = Dict.new()
+  }
+}
+```

docs/language/dict/dict-remove.md

@@ -0,0 +1,22 @@
+---
+id: dict-remove
+name: Dict.remove
+category: dict
+kind: namespace-method
+tokens: Dict.remove
+sig: Dict.remove(d, key)
+tip: Delete a key.
+order: 5
+ns: Dict
+member: remove
+---
+
+Removes <code>key</code> from the map (a no-op if it is absent). Later lookups of other keys are unaffected.
+
+```ludic
+program Demo {
+  handler Step phase Update {
+    Dict.remove(bank, "wood")
+  }
+}
+```

docs/language/dict/dict-set.md

@@ -0,0 +1,22 @@
+---
+id: dict-set
+name: Dict.set
+category: dict
+kind: namespace-method
+tokens: Dict.set
+sig: Dict.set(d, key, value)
+tip: Insert or update a key.
+order: 1
+ns: Dict
+member: set
+---
+
+Associates <code>value</code> with <code>key</code>, inserting it or overwriting the previous value. The table grows automatically as it fills.
+
+```ludic
+program Demo {
+  handler Step phase Update {
+    Dict.set(bank, "gold", 100)
+  }
+}
+```

docs/language/dict/dict-size.md

@@ -0,0 +1,22 @@
+---
+id: dict-size
+name: Dict.size
+category: dict
+kind: namespace-method
+tokens: Dict.size
+sig: Dict.size(d) -> int
+tip: How many keys are stored.
+order: 6
+ns: Dict
+member: size
+---
+
+Returns the number of keys currently in the map.
+
+```ludic
+program Demo {
+  handler Step phase Update {
+    let kinds = Dict.size(bank)
+  }
+}
+```

docs/language/set/_section.md

@@ -0,0 +1,7 @@
+---
+id: set
+title: Set
+order: 13
+---
+
+A set of string members — membership tests for tags, unlocked achievements, or visited tiles. A <code>Set</code> shares the same open-addressing hash table as <code>Dict</code>, so <code>add</code> / <code>has</code> / <code>remove</code> are O(1) on average and duplicates are ignored. Create one with <code>Set.new</code>, then <code>add</code> / <code>has</code> / <code>remove</code> / <code>size</code> / <code>clear</code> / <code>members</code>. Arguments are positional. The runtime is spliced in only when a program mentions <code>Set.*</code> (or <code>Dict.*</code>).

docs/language/set/set-add.md

@@ -0,0 +1,22 @@
+---
+id: set-add
+name: Set.add
+category: set
+kind: namespace-method
+tokens: Set.add
+sig: Set.add(s, key)
+tip: Add a member (duplicates ignored).
+order: 1
+ns: Set
+member: add
+---
+
+Adds <code>key</code> to the set. Adding a member that is already present is a harmless no-op.
+
+```ludic
+program Demo {
+  handler Step phase Update {
+    Set.add(tags, "poison")
+  }
+}
+```

docs/language/set/set-clear.md

@@ -0,0 +1,22 @@
+---
+id: set-clear
+name: Set.clear
+category: set
+kind: namespace-method
+tokens: Set.clear
+sig: Set.clear(s)
+tip: Remove every member.
+order: 5
+ns: Set
+member: clear
+---
+
+Empties the set, removing every member while keeping its allocated capacity.
+
+```ludic
+program Demo {
+  handler Step phase Update {
+    Set.clear(tags)
+  }
+}
+```

docs/language/set/set-has.md

@@ -0,0 +1,22 @@
+---
+id: set-has
+name: Set.has
+category: set
+kind: namespace-method
+tokens: Set.has
+sig: Set.has(s, key) -> bool
+tip: Is a member present?
+order: 2
+ns: Set
+member: has
+---
+
+Returns true when <code>key</code> is a member of the set.
+
+```ludic
+program Demo {
+  handler Step phase Update {
+    if Set.has(tags, "poison") { tick() }
+  }
+}
+```

docs/language/set/set-members.md

@@ -0,0 +1,22 @@
+---
+id: set-members
+name: Set.members
+category: set
+kind: namespace-method
+tokens: Set.members
+sig: Set.members(s) -> []pointer
+tip: Every member, as a slice of strings.
+order: 6
+ns: Set
+member: members
+---
+
+Returns every member as a slice of strings, in unspecified order — iterate it with <code>len</code> and indexing.
+
+```ludic
+program Demo {
+  handler Step phase Update {
+    let all = Set.members(tags)
+  }
+}
+```

docs/language/set/set-new.md

@@ -0,0 +1,22 @@
+---
+id: set-new
+name: Set.new
+category: set
+kind: namespace-method
+tokens: Set.new
+sig: Set.new() -> Set
+tip: Create an empty string set.
+order: 0
+ns: Set
+member: new
+---
+
+Creates an empty <code>Set</code> of string members. Add to it with <code>Set.add</code> and test membership with <code>Set.has</code>.
+
+```ludic
+program Demo {
+  handler Step phase Update {
+    let tags = Set.new()
+  }
+}
+```

docs/language/set/set-remove.md

@@ -0,0 +1,22 @@
+---
+id: set-remove
+name: Set.remove
+category: set
+kind: namespace-method
+tokens: Set.remove
+sig: Set.remove(s, key)
+tip: Remove a member.
+order: 3
+ns: Set
+member: remove
+---
+
+Removes <code>key</code> from the set (a no-op if it is not a member).
+
+```ludic
+program Demo {
+  handler Step phase Update {
+    Set.remove(tags, "fire")
+  }
+}
+```

docs/language/set/set-size.md

@@ -0,0 +1,22 @@
+---
+id: set-size
+name: Set.size
+category: set
+kind: namespace-method
+tokens: Set.size
+sig: Set.size(s) -> int
+tip: How many members.
+order: 4
+ns: Set
+member: size
+---
+
+Returns the number of members in the set.
+
+```ludic
+program Demo {
+  handler Step phase Update {
+    let n = Set.size(tags)
+  }
+}
+```