BridgeJS: Hoist stack codecs into named module-scope helpers

Two sites described the same stack ABI twice. Container element positions
without a named codec emitted a local `const elemCodec = {lower, lift}`
literal, re-declared at every lower/lift site, and the generic type-handle
registration emitted an anonymous `{lower, lift}` literal per module type.

Emit one named `{lower, lift}` helper per type shape at module scope instead,
next to the combinators and the primitive codec table, and have both the
element positions and the registration table reference it. Helpers for `@JS`
structs and associated-value enums delegate to the existing
`structHelpers`/`enumHelpers` entries rather than re-emitting their
marshalling; the thin adapter is what lets a helper be a module-scope const
even though those tables are populated later, in `createExports`. The
associated-value enum combinator is gone: its adapter is now the type's
helper.

Composed codecs (`[T]`, `T?`, `[String: T]` and their nestings) are hoisted
the same way and deduplicated across the whole glue, so a generated thunk no
longer builds a codec on every call — previously each call ran e.g.
`__bjs_dictCodec(__bjs_optionalCodec(__bjs_primitiveCodecs.Int)).lower(...)`.

Helper names derived from type names are qualified with the declaring module,
and composed names inherit that qualification from their element, so two
modules declaring same-named `@JS` types cannot mint the same identifier.

Author: krodak

Plugins/BridgeJS/Sources/BridgeJSLink/BridgeJSLink.swift

@@ -420,22 +420,13 @@ public struct BridgeJSLink {
         )
     }
 
-    /// Emits a `{ lower, lift }` codec literal for one bridgeable type.
-    /// `prefix` is prepended to the opening brace (e.g. an assignment) and
-    /// `suffix` is appended to the closing brace (e.g. `","` in an array).
-    private func appendGenericCodecLiteral(
-        type: BridgeType,
-        into printer: CodeFragmentPrinter,
-        prefix: String = "",
-        suffix: String = ","
-    ) throws {
-        try ContainerCodecJS.writeCodecLiteral(
-            type: type,
-            into: printer,
-            context: makeCodecPrintContext(printer: printer),
-            prefix: prefix,
-            suffix: suffix
-        )
+    /// Returns the module-scope codec helper for one bridgeable type, declaring
+    /// it if this is the first reference.
+    ///
+    /// The registration table and the container combinators' element positions
+    /// go through the same helper, so a type's stack ABI is described once.
+    private func genericCodecReference(type: BridgeType, into printer: CodeFragmentPrinter) throws -> String {
+        try ContainerCodecJS.codecExpression(for: type, context: makeCodecPrintContext(printer: printer))
     }
 
     /// Writes the body shared by every registration hook: verify the codec array
@@ -509,10 +500,13 @@ public struct BridgeJSLink {
             printer.write("bjs[\"\(hookName)\"] = function(base, count) {")
             try printer.indent {
                 // Same order as the module's Swift registration function.
+                let codecNames = try moduleEntries.map {
+                    try genericCodecReference(type: $0.bridgeType, into: printer)
+                }
                 printer.write("const codecs = [")
-                try printer.indent {
-                    for entry in moduleEntries {
-                        try appendGenericCodecLiteral(type: entry.bridgeType, into: printer)
+                printer.indent {
+                    for name in codecNames {
+                        printer.write("\(name),")
                     }
                 }
                 printer.write("];")
@@ -1303,6 +1297,18 @@ public struct BridgeJSLink {
                 printer.nextLine()
             }
 
+            // The named codec helpers come after the intrinsics because they are
+            // built out of the combinators and the primitive codec table, and
+            // before everything that uses them: they are hoisted here so that no
+            // call site ever composes a codec. Helpers that delegate to the
+            // `structHelpers` / `enumHelpers` tables only read those tables when
+            // called, so declaring them ahead of the tables being populated is
+            // fine.
+            if intrinsicRegistry.hasNamedCodecs {
+                printer.write(lines: intrinsicRegistry.emitNamedCodecLines())
+                printer.nextLine()
+            }
+
             printer.write(lines: bodyPrinter.lines)
         }
         printer.indent()
@@ -1406,12 +1412,54 @@ public struct BridgeJSLink {
                 }
             }
         }
+        intrinsicRegistry.typeOwnerModules = collectTypeOwnerModules()
         let data = try collectLinkData()
         let outputJs = try generateJavaScript(data: data)
         let outputDts = generateTypeScript(data: data)
         return (outputJs, outputDts)
     }
 
+    /// Maps every type name a `BridgeType` can carry to the module that declares
+    /// it, so identifiers minted from type names can be module-qualified.
+    ///
+    /// A name declared by two modules is a pre-existing ambiguity in the
+    /// skeleton format (`BridgeType` carries only the name), so the first
+    /// declaration wins, which keeps the output deterministic.
+    private func collectTypeOwnerModules() -> [String: String] {
+        var result: [String: String] = [:]
+        func record(_ name: String, _ moduleName: String) {
+            if result[name] == nil {
+                result[name] = moduleName
+            }
+        }
+        for unified in skeletons {
+            let moduleName = unified.moduleName
+            if let skeleton = unified.exported {
+                for structDef in skeleton.structs {
+                    record(structDef.name, moduleName)
+                    record(structDef.abiName, moduleName)
+                }
+                for klass in skeleton.classes {
+                    record(klass.name, moduleName)
+                    record(klass.abiName, moduleName)
+                }
+                for enumDef in skeleton.enums {
+                    record(enumDef.name, moduleName)
+                    record(enumDef.abiName, moduleName)
+                }
+                for protocolDef in skeleton.protocols {
+                    record(protocolDef.name, moduleName)
+                }
+            }
+            for file in unified.imported?.children ?? [] {
+                for type in file.types {
+                    record(type.name, moduleName)
+                }
+            }
+        }
+        return result
+    }
+
     private func enumHelperAssignments() -> CodeFragmentPrinter {
         let printer = CodeFragmentPrinter()