feat(diag): report a missing std-namespace import in Xi, not C

Extends missing-import diagnostics to namespaced std modules. `json.foo(...)`
without `import "std/json.xi"` now reports
`file.xi:3: error: json.foo(...) — the 'json' namespace isn't imported; add:
import "std/json.xi"` instead of leaking `undeclared identifier 'json'`.

Hooked at the identifier fallback, guarded so it only fires when: the name is a
known std namespace (json/yaml/xml/crypto/math/text/bytes/net/fs/path/time/http/
io/proc/vec/web), it's followed by `.`, it isn't a local var, and no `<ns>__<fn>`
function exists (i.e. the namespace really isn't imported) — so imported
namespaces and locals are never flagged. Verified across every example (0 false
positives); the check also caught a genuine latent bug — thread_demo used
int_to_string without importing std/convert — now fixed. Fixpoint byte-identical;
22 test files pass.

Author: code-by-sia

compiler/impl/codegen/expr.xi

@@ -511,6 +511,15 @@ mapper genPrimary(toks: Token[], pos: Integer, ctx: GCtx) -> ExprRes {
         if (ctx.prog).isMachineTypeC(txt) {
             return ExprRes { code: txt, pos: pos + 1, xtyp: "machinetype:" + txt , owned: false }
         }
+        // `ns.foo(...)` where `ns` is a std namespace that isn't imported: no
+        // `ns__foo` function exists, `ns` isn't a local — report the missing import
+        // in Xi terms rather than leaking a C `undeclared identifier 'ns'` error.
+        if toks.kindAt(pos + 1) == 107 and string_len(ctx.lookupVar(txt)) == 0 {
+            let nsImp = txt.stdNamespaceImport()
+            if string_len(nsImp) > 0 and not (ctx.prog).isFuncNameC(txt + "__" + toks.textAt(pos + 2)) {
+                diag_error(tokenArrGet(toks, pos).line, txt + "." + toks.textAt(pos + 2) + "(...) — the '" + txt + "' namespace isn't imported; add:  import \"" + nsImp + "\"")
+            }
+        }
         return ExprRes { code: txt, pos: pos + 1, xtyp: ctx.lookupVar(txt) , owned: false }
     }
     return ExprRes { code: txt, pos: pos + 1, xtyp: "" , owned: false }

compiler/impl/codegen/program_query.xi

@@ -317,6 +317,28 @@ mapper String.stdImportHint() -> String {
     return ""
 }
 
+// If `this` is a std-library namespace, the import path that provides it; else ""
+// (used to report `json.foo(...)` when `std/json.xi` isn't imported).
+mapper String.stdNamespaceImport() -> String {
+    if this == "json"   { return "std/json.xi" }
+    if this == "yaml"   { return "std/yaml.xi" }
+    if this == "xml"    { return "std/xml.xi" }
+    if this == "crypto" { return "std/crypto.xi" }
+    if this == "math"   { return "std/math.xi" }
+    if this == "text"   { return "std/text.xi" }
+    if this == "bytes"  { return "std/bytes.xi" }
+    if this == "net"    { return "std/net.xi" }
+    if this == "fs"     { return "std/fs.xi" }
+    if this == "path"   { return "std/path.xi" }
+    if this == "time"   { return "std/time.xi" }
+    if this == "http"   { return "std/http.xi" }
+    if this == "io"     { return "std/io.xi" }
+    if this == "proc"   { return "std/process.xi" }
+    if this == "vec"    { return "std/vec.xi" }
+    if this == "web"    { return "std/web.xi" }
+    return ""
+}
+
 // The X type of module-scoped const `Module.name`, or "" if there's no such const.
 mapper Program.moduleConstXType(moduleName: String, name: String) -> String {
     let i = 0

examples/concurrency/thread_demo.xi

@@ -5,6 +5,7 @@
 //   xc examples/thread_demo.xi && ./build/thread_demo
 import "std/log.xi"
 import "std/thread.xi"
+import "std/convert.xi"
 
 async entry (logger: Logger) main(args: String[]) -> Integer {
     let jobs    = thread.channel()