fix(module_loader): memoise transitive flattening; assert field-not-found

Review follow-up (CodeRabbit on #777): a module shared by several import
paths (a diamond) was re-flattened once per path, which grows
exponentially with depth; completed flattened programs are now cached for
the duration of one flatten_imports call (the cycle guard is unchanged).
The imported-struct negative test now asserts the specific
"Field 'z' not found" diagnostic. dune main 562 OK; Bun-ESM 39/39; WASM 38/38.

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

Author: hyperpolymath

lib/module_loader.ml

@@ -277,7 +277,9 @@ let clear_cache (loader : t) : unit =
     this function retains the same last-import policy as a defensive fallback
     for callers that flatten an already-loaded program directly. Local decls
     in [prog.prog_decls] always win over imported ones. *)
-let rec flatten_imports_from (visiting : string list list) (loader : t)
+let rec flatten_imports_from
+    (cache : (string list, program) Hashtbl.t)
+    (visiting : string list list) (loader : t)
     (prog : program) : program =
   (* Local-decl names suppress same-named imports of any kind. *)
   let local_name_list =
@@ -318,8 +320,18 @@ let rec flatten_imports_from (visiting : string list list) (loader : t)
            undefined `subs`. [visiting] stops an import cycle. *)
         let lm =
           if List.mem mod_path visiting then lm0
-          else { lm0 with mod_program =
-                   flatten_imports_from (mod_path :: visiting) loader lm0.mod_program }
+          else
+            (* Memoised per flatten call: a module shared by several import
+               paths (a diamond) is flattened once, not once per path. *)
+            let flat = match Hashtbl.find_opt cache mod_path with
+              | Some p -> p
+              | None ->
+                let p = flatten_imports_from cache (mod_path :: visiting) loader
+                    lm0.mod_program in
+                Hashtbl.replace cache mod_path p;
+                p
+            in
+            { lm0 with mod_program = flat }
         in
         let public_decls = List.filter_map (fun decl ->
           match decl with
@@ -512,4 +524,4 @@ let rec flatten_imports_from (visiting : string list list) (loader : t)
 (** Inline the declarations [prog]'s imports need (transitively) into [prog],
     for the backends that compile one flattened program. *)
 let flatten_imports (loader : t) (prog : program) : program =
-  flatten_imports_from [] loader prog
+  flatten_imports_from (Hashtbl.create 8) [] loader prog

test/test_records_and_imports.ml

@@ -92,7 +92,8 @@ let imported_struct_fields () =
 let imported_struct_unknown_field_rejected () =
   let dir = module_dir "Shapes2"
       "module Shapes2;\npub struct Point { x: Float, y: Float }\n" in
-  fails ~dir ~needles:[ "z" ] "use Shapes2::{Point};\npub fn f(p: Point) -> Float = p.z;\n"
+  fails ~dir ~needles:[ "Field 'z' not found" ]
+    "use Shapes2::{Point};\npub fn f(p: Point) -> Float = p.z;\n"
 
 (* A function-local binding must not replace the module-level binding of
    the same name in what importers see. *)