feat: lifetime elision, tooling CI, registry, and LSP locals

Ship the QUALITY_PLAN stretch from ownership through ecosystem: C.1
lifetime elision (bootstrap + selfhost), bux fmt/test/doc CI hooks,
stdlib goldens, package registry (bux search/add), and LSP 0.4
position-sensitive locals with inferred let types. Full-tree format
pass plus Map/Set remove double-free fix.

lib/Set.bux

@@ -1,112 +1,116 @@
 module Std::Set {
 
-extern func bux_hash_bytes(ptr: *void, size: uint) -> uint;
-extern func bux_mem_eq(a: *void, b: *void, size: uint) -> int;
-extern func bux_alloc(size: uint) -> *void;
-extern func bux_free(ptr: *void);
+    extern func bux_hash_bytes(ptr: *void, size: uint) -> uint;
+    extern func bux_mem_eq(a: *void, b: *void, size: uint) -> int;
+    extern func bux_alloc(size: uint) -> *void;
+    extern func bux_free(ptr: *void);
 
-struct SetEntry<T> {
-    value: T,
-    occupied: bool,
-}
-
-struct Set<T> {
-    entries: *SetEntry<T>,
-    cap: uint,
-    len: uint,
-}
-
-func Set_New<T>(cap: uint) -> Set<T> {
-    let total: uint = cap * sizeof(SetEntry<T>);
-    let data: *SetEntry<T> = bux_alloc(total) as *SetEntry<T>;
-    var i: uint = 0;
-    while i < cap {
-        data[i].occupied = false;
-        i = i + 1;
+    struct SetEntry<T> {
+        value: T,
+        occupied: bool,
     }
-    return Set<T> { entries: data, cap: cap, len: 0 };
-}
 
-func Set_Add<T>(s: *Set<T>, value: T) {
-    var valuePtr: *T = &value;
-    let hash: uint = bux_hash_bytes(valuePtr as *void, sizeof(T));
-    var idx: uint = hash % s.cap;
-    while s.entries[idx].occupied {
-        var entryPtr: *T = &s.entries[idx].value;
-        if bux_mem_eq(entryPtr as *void, valuePtr as *void, sizeof(T)) != 0 {
-            return;
+    struct Set<T> {
+        entries: *SetEntry<T>,
+        cap: uint,
+        len: uint,
+    }
+
+    func Set_New<T>(cap: uint) -> Set<T> {
+        let total: uint = cap * sizeof(SetEntry<T>);
+        let data: *SetEntry<T> = bux_alloc(total) as *SetEntry<T>;
+        var i: uint = 0;
+        while i < cap {
+            data[i].occupied = false;
+            i = i + 1;
         }
-        idx = (idx + 1) % s.cap;
+        return Set<T> { entries: data, cap: cap, len: 0 };
     }
-    s.entries[idx].value = value;
-    s.entries[idx].occupied = true;
-    s.len = s.len + 1;
-}
 
-func Set_Has<T>(s: *Set<T>, value: T) -> bool {
-    var valuePtr: *T = &value;
-    let hash: uint = bux_hash_bytes(valuePtr as *void, sizeof(T));
-    var idx: uint = hash % s.cap;
-    while s.entries[idx].occupied {
-        var entryPtr: *T = &s.entries[idx].value;
-        if bux_mem_eq(entryPtr as *void, valuePtr as *void, sizeof(T)) != 0 {
-            return true;
+    func Set_Add<T>(s: *Set<T>, value: T) {
+        var valuePtr: *T = &value;
+        let hash: uint = bux_hash_bytes(valuePtr as *void, sizeof(T));
+        var idx: uint = hash % s.cap;
+        while s.entries[idx].occupied {
+            var entryPtr: *T = &s.entries[idx].value;
+            if bux_mem_eq(entryPtr as *void, valuePtr as *void, sizeof(T)) != 0 {
+                return;
+            }
+            idx = (idx + 1) % s.cap;
         }
-        idx = (idx + 1) % s.cap;
+        s.entries[idx].value = value;
+        s.entries[idx].occupied = true;
+        s.len = s.len + 1;
     }
-    return false;
-}
 
-func Set_Len<T>(s: *Set<T>) -> uint {
-    return s.len;
-}
-
-func Set_IsEmpty<T>(s: *Set<T>) -> bool {
-    return s.len == 0;
-}
-
-/* Remove value if present. Rebuilds the table to keep open-addressing correct. */
-func Set_Remove<T>(s: *Set<T>, value: T) -> bool {
-    if !Set_Has<T>(s, value) {
+    func Set_Has<T>(s: *Set<T>, value: T) -> bool {
+        var valuePtr: *T = &value;
+        let hash: uint = bux_hash_bytes(valuePtr as *void, sizeof(T));
+        var idx: uint = hash % s.cap;
+        while s.entries[idx].occupied {
+            var entryPtr: *T = &s.entries[idx].value;
+            if bux_mem_eq(entryPtr as *void, valuePtr as *void, sizeof(T)) != 0 {
+                return true;
+            }
+            idx = (idx + 1) % s.cap;
+        }
         return false;
     }
-    var fresh: Set<T> = Set_New<T>(s.cap);
-    var i: uint = 0;
-    while i < s.cap {
-        if s.entries[i].occupied {
-            var entryPtr: *T = &s.entries[i].value;
-            var valuePtr: *T = &value;
-            if bux_mem_eq(entryPtr as *void, valuePtr as *void, sizeof(T)) == 0 {
-                Set_Add<T>(&fresh, s.entries[i].value);
-            }
+
+    func Set_Len<T>(s: *Set<T>) -> uint {
+        return s.len;
+    }
+
+    func Set_IsEmpty<T>(s: *Set<T>) -> bool {
+        return s.len == 0;
+    }
+
+    /* Remove value if present. Rebuilds the table to keep open-addressing correct. */
+    func Set_Remove<T>(s: *Set<T>, value: T) -> bool {
+        if !Set_Has<T>(s, value) {
+            return false;
         }
-        i = i + 1;
+        var fresh: Set<T> = Set_New<T>(s.cap);
+        var i: uint = 0;
+        while i < s.cap {
+            if s.entries[i].occupied {
+                var entryPtr: *T = &s.entries[i].value;
+                var valuePtr: *T = &value;
+                if bux_mem_eq(entryPtr as *void, valuePtr as *void, sizeof(T)) == 0 {
+                    Set_Add<T>(&fresh, s.entries[i].value);
+                }
+            }
+            i = i + 1;
+        }
+        bux_free(s.entries as *void);
+        s.entries = fresh.entries;
+        s.cap = fresh.cap;
+        s.len = fresh.len;
+        // Ownership transferred to `s` — clear `fresh` so auto-Drop does not free twice
+        fresh.entries = null as *SetEntry<T>;
+        fresh.cap = 0;
+        fresh.len = 0;
+        return true;
     }
-    bux_free(s.entries as *void);
-    s.entries = fresh.entries;
-    s.cap = fresh.cap;
-    s.len = fresh.len;
-    return true;
-}
 
-func Set_Clear<T>(s: *Set<T>) {
-    var i: uint = 0;
-    while i < s.cap {
-        s.entries[i].occupied = false;
-        i = i + 1;
+    func Set_Clear<T>(s: *Set<T>) {
+        var i: uint = 0;
+        while i < s.cap {
+            s.entries[i].occupied = false;
+            i = i + 1;
+        }
+        s.len = 0;
     }
-    s.len = 0;
-}
 
-func Set_Free<T>(s: *Set<T>) {
-    bux_free(s.entries as *void);
-    s.entries = null as *SetEntry<T>;
-    s.cap = 0;
-    s.len = 0;
-}
+    func Set_Free<T>(s: *Set<T>) {
+        bux_free(s.entries as *void);
+        s.entries = null as *SetEntry<T>;
+        s.cap = 0;
+        s.len = 0;
+    }
 
-func Set_Drop<T>(s: *Set<T>) {
-    Set_Free<T>(s);
-}
+    func Set_Drop<T>(s: *Set<T>) {
+        Set_Free<T>(s);
+    }
 
 }