jolt build: compile an app to a standalone binary (Phase 4 stages 1-2)

Restores the standalone-binary capability the Janet host had. `bin/joltc build
-m NS -o OUT` AOT-compiles an app into a single self-contained executable — the
whole runtime, clojure.core, stdlib and compiler embedded, no Chez install or
jolt source needed at runtime.

Pipeline (host/chez/build.ss, host primitive jolt.host/build-binary driven by
jolt.main's build command): resolve deps, load the entry namespace recording the
app namespaces in dependency order, re-emit each to Scheme, textually inline the
cli.ss runtime load sequence into one flat source + the app + a launcher, then
compile-file -> make-boot-file -> embed the boot as C bytes -> cc-link against
libkernel.a.

Two non-obvious bits: the compile pass runs in a fresh Chez, not the loaded
runtime (regex.ss shadows top-level `error`, which otherwise bakes a broken
reference into the boot); and the launcher installs scheme-start rather than
running -main at top level, since boot top-level forms execute during heap build
before argv is set, so args only reach -main through scheme-start.

Loader: a require of an in-memory namespace with no source file now no-ops, so
AOT'd app namespaces satisfy require in a built binary.

Mode flags (--opt/--dev, default release) are plumbed; the optimization passes
they gate come in a later stage. RFC 0007 has the design. Gated by `make
buildsmoke`.

host/chez/loader.ss

@@ -53,6 +53,23 @@
 (vector-for-each (lambda (c) (hashtable-set! loaded-ns (var-cell-ns c) #t))
                  (hashtable-values var-table))
 
+;; Does `name` already have vars in the var-table? A namespace baked into the
+;; image after the snapshot above — an AOT'd app namespace in a `jolt build`
+;; binary — exists in memory with no source file; a later `require` of it must
+;; no-op rather than hunt the (absent) source.
+(define (ns-has-vars? name)
+  (let ((found #f))
+    (vector-for-each
+      (lambda (c) (when (and (not found) (string=? (var-cell-ns c) name)) (set! found #t)))
+      (hashtable-values var-table))
+    found))
+
+;; Called after a file-backed namespace finishes loading, with (name file). The
+;; build driver sets this to record app namespaces in dependency order for AOT
+;; emission; a no-op for normal runs.
+(define ns-loaded-hook (lambda (name file) #f))
+(define (set-ns-loaded-hook! f) (set! ns-loaded-hook f))
+
 ;; Read every form from a file and compile+eval it in turn. The first form is
 ;; normally (ns …), which expands to (in-ns …) and switches the current ns, so
 ;; later forms compile in that namespace — (chez-current-ns) is re-read each step.
@@ -80,17 +97,22 @@
 ;; restored afterward, since loading the file switched it.
 (define (load-namespace name)
   (unless (hashtable-ref loaded-ns name #f)
-    (hashtable-set! loaded-ns name #t)
     (let ((file (find-ns-file name)))
-      (if (not file)
-          (begin
-            (hashtable-delete! loaded-ns name)
-            (error #f (string-append "Could not locate " (ns-name->rel name)
-                                     ".clj (or .cljc) on the source roots") name))
-          (let ((saved (chez-current-ns)))
-            (load-jolt-file file)
-            ;; restore the current ns (thread-local); *ns* reads derive from it.
-            (set-chez-ns! saved))))))
+      (cond
+        (file
+         (hashtable-set! loaded-ns name #t)   ; mark before load so a cycle terminates
+         (let ((saved (chez-current-ns)))
+           (load-jolt-file file)
+           ;; restore the current ns (thread-local); *ns* reads derive from it.
+           (set-chez-ns! saved))
+         (ns-loaded-hook name file))
+        ;; No source file but the namespace exists in memory (AOT'd into a built
+        ;; binary): it's already defined — mark loaded and move on.
+        ((ns-has-vars? name)
+         (hashtable-set! loaded-ns name #t))
+        (else
+         (error #f (string-append "Could not locate " (ns-name->rel name)
+                                  ".clj (or .cljc) on the source roots") name))))))
 
 ;; load-file: load an explicit path (a `run FILE`), in the current ns.
 (define (jolt-load-file path)