docs: update README, Stdlib, BuildAndTest, PLAN for new std modules

Added documentation for:
- Std::Fs (DirExists, Mkdir, ListDir)
- Std::Mem (Alloc, Free, MemEq, New)
- Std::Set<T> (Set_New, Set_Add, Set_Has)
- String_Find, String_Replace, String_Format

Updated PLAN.md blockers (all resolved) and self-host status.
Updated README.md project structure and feature table.
Updated BuildAndTest.md with new stdlib modules and path syntax.

Also includes:
- CLI path argument fix (build/check/run accept project path)
- Remove dummyFunc from parser
- Fix String_Replace to use String_Concat instead of buggy str_join2

stdlib/Std/Fs.bux

@@ -0,0 +1,19 @@
+module Std::Fs {
+
+extern func bux_dir_exists(path: String) -> int;
+extern func bux_mkdir_if_needed(path: String) -> int;
+extern func bux_list_dir(dir: String, ext: String, out_count: *int) -> *String;
+
+func DirExists(path: String) -> bool {
+    return bux_dir_exists(path) != 0;
+}
+
+func Mkdir(path: String) -> bool {
+    return bux_mkdir_if_needed(path) != 0;
+}
+
+func ListDir(dir: String, ext: String, count: *int) -> *String {
+    return bux_list_dir(dir, ext, count);
+}
+
+}

stdlib/Std/Mem.bux

@@ -0,0 +1,29 @@
+module Std::Mem {
+
+extern func bux_alloc(size: uint) -> *void;
+extern func bux_realloc(ptr: *void, size: uint) -> *void;
+extern func bux_free(ptr: *void);
+extern func bux_mem_eq(a: *void, b: *void, size: uint) -> int;
+
+func Alloc(size: uint) -> *void {
+    return bux_alloc(size);
+}
+
+func Realloc(ptr: *void, size: uint) -> *void {
+    return bux_realloc(ptr, size);
+}
+
+func Free(ptr: *void) {
+    bux_free(ptr);
+}
+
+func MemEq(a: *void, b: *void, size: uint) -> bool {
+    return bux_mem_eq(a, b, size) != 0;
+}
+
+func New<T>() -> *T {
+    let sz: uint = sizeof(T);
+    return bux_alloc(sz) as *T;
+}
+
+}

stdlib/Std/Set.bux

@@ -0,0 +1,71 @@
+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);
+
+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;
+    }
+    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;
+        }
+        idx = (idx + 1) % s.cap;
+    }
+    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;
+        }
+        idx = (idx + 1) % s.cap;
+    }
+    return false;
+}
+
+func Set_Len<T>(s: *Set<T>) -> uint {
+    return s.len;
+}
+
+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;
+}
+
+}

stdlib/Std/String.bux

@@ -24,6 +24,7 @@ extern func bux_sb_free(sb: *void);
 extern func bux_str_split_count(s: String, delim: String) -> uint;
 extern func bux_str_split_part(s: String, delim: String, index: uint) -> String;
 extern func bux_str_join2(a: String, b: String, sep: String) -> String;
+extern func bux_str_format(pattern: String, a0: String, a1: String, a2: String, a3: String, a4: String, a5: String, a6: String, a7: String) -> String;
 
 
 func String_Len(s: String) -> uint {
@@ -155,4 +156,38 @@ func String_Join2(a: String, b: String, sep: String) -> String {
     return bux_str_join2(a, b, sep);
 }
 
-}
+// ---------------------------------------------------------------------------
+// String find/replace/format
+// ---------------------------------------------------------------------------
+
+func String_Find(haystack: String, needle: String) -> String {
+    return bux_strstr(haystack, needle);
+}
+
+func String_Replace(s: String, old: String, new: String) -> String {
+    let pos: String = bux_strstr(s, old);
+    if pos as uint == 0 {
+        return s;
+    }
+    let oldLen: uint = bux_strlen(old);
+    let prefixLen: uint = pos as uint - s as uint;
+    let prefix: String = bux_str_slice(s, 0, prefixLen);
+    let suffix: String = bux_str_slice(s, prefixLen + oldLen, bux_strlen(s) - prefixLen - oldLen);
+    let temp: String = String_Concat(prefix, new);
+    let result: String = String_Concat(temp, suffix);
+    return result;
+}
+
+func String_Format1(pattern: String, a0: String) -> String {
+    return bux_str_format(pattern, a0, "", "", "", "", "", "", "");
+}
+
+func String_Format2(pattern: String, a0: String, a1: String) -> String {
+    return bux_str_format(pattern, a0, a1, "", "", "", "", "", "");
+}
+
+func String_Format3(pattern: String, a0: String, a1: String, a2: String) -> String {
+    return bux_str_format(pattern, a0, a1, a2, "", "", "", "", "");
+}
+
+}