feat: add opt-in "swift" identity mode with Swift-owned strong cache

Introduces a third value for @js(identityMode:): .swift, alongside the
existing .none (default) and .pointer (weak JS-side cache shipped in main).

With .swift mode, Swift owns the wrapper lifetime via per-class tables:

    var _<Class>_identityTable: [UnsafeMutableRawPointer: Int32]  // ptr → id
    var _<Class>_idToPointer:   [Int32: UnsafeMutableRawPointer]  // id → ptr
    var _<Class>_wrapperRefs:   [Int32]                           // id → JS ref
    var _<Class>_freeIds:       [Int32]
    var _<Class>_nextId:        Int32

On return, Swift looks up the pointer; on miss it retains, allocates an id,
and pushes (id, freshBit) on the existing i32 stack. JS pops the pair, and
either returns cache[id] (hit) or builds a wrapper and calls back via
bjs_<Class>_register_wrapper to install the retained JS ref. Release is
driven by an explicit bjs_<Class>_release_wrapper(id) export.

The miss-heavy regression of .pointer mode (FinalizationRegistry.register +
new WeakRef + Map.set account for 88% of miss cost per Phase 0 profiling)
is addressed: .swift mode keeps no WeakRef, no FinalizationRegistry, no
per-miss Map.set — just a dense array indexed by Swift-assigned id.

Per-class opt-in via @js(identityMode: .swift); project-wide default via
"identityMode": "swift" in bridge-js.config.json. A JSIdentityMode enum
replaces the legacy identityMode: Bool macro parameter; true/false literals
are still accepted at parse time for backward compatibility.

Changes:

 - New JSIdentityMode enum + macro parameter migration (Bool → enum)
 - Skeleton.identityMode: Bool? → String?, with per-class and config-default
   resolution threaded through ExportSwift and BridgeJSLink
 - New Wasm intrinsic _swift_js_release_ref
 - ExportSwift emits per-class tables + register/release thunks +
   bridgeJSStackPush override for array-element returns
 - BridgeJSLink emits a standalone SwiftIdentityHeapObject template
   (no SwiftHeapObject inheritance, no FinalizationRegistry, no WeakRef)
   with a use-after-release guard on every instance member
 - New BridgeJSSwiftIdentityTests target for config-default opt-in E2E
   coverage; extends BridgeJSIdentityTests with per-class opt-in scenarios
 - *SwiftIdentity benchmark variants + three-mode harness in identity-benchmarks.js
 - DocC article Identity-Modes-For-Exported-Classes.md; cross-references
   from Exporting-Swift-Class.md, Exporting-Swift-to-JavaScript.md,
   BridgeJS-Configuration.md

Author: krodak

Benchmarks/Package.swift

@@ -12,13 +12,13 @@ let package = Package(
         .macCatalyst(.v13),
     ],
     dependencies: [
-        .package(path: "../")
+        .package(name: "JavaScriptKit", path: "../")
     ],
     targets: [
         .executableTarget(
             name: "Benchmarks",
             dependencies: [
-                "JavaScriptKit",
+                .product(name: "JavaScriptKit", package: "JavaScriptKit"),
                 .product(name: "JavaScriptFoundationCompat", package: "JavaScriptKit"),
             ],
             exclude: ["Generated/JavaScript", "bridge-js.d.ts"],

Benchmarks/Sources/Benchmarks.swift

@@ -305,11 +305,11 @@ nonisolated(unsafe) var _cachedPool: [SimpleClass] = []
     }
 }
 
-// MARK: - Identity Mode Benchmark Variants
-// These classes use @JS(identityMode: true) so that identity cache benchmarks
+// MARK: - Identity Mode Benchmark Variants (pointer mode)
+// These classes use @JS(identityMode: .pointer) so that identity cache benchmarks
 // can run in the SAME build alongside the non-identity classes above.
 
-@JS(identityMode: true)
+@JS(identityMode: .pointer)
 class SimpleClassIdentity {
     @JS var name: String
     @JS var count: Int
@@ -326,7 +326,7 @@ class SimpleClassIdentity {
     }
 }
 
-@JS(identityMode: true)
+@JS(identityMode: .pointer)
 class ClassRoundtripIdentity {
     @JS init() {}
 
@@ -345,7 +345,7 @@ class ClassRoundtripIdentity {
 
 nonisolated(unsafe) var _cachedPoolIdentity: [SimpleClassIdentity] = []
 
-@JS(identityMode: true)
+@JS(identityMode: .pointer)
 class IdentityCacheBenchmarkIdentity {
     @JS init() {}
 
@@ -360,6 +360,61 @@ class IdentityCacheBenchmarkIdentity {
     }
 }
 
+// MARK: - Identity Mode Benchmark Variants (swift-owned cache)
+// Parallel set using @JS(identityMode: .swift) so the third mode can run
+// in the same build alongside the other two.
+
+@JS(identityMode: .swift)
+class SimpleClassSwiftIdentity {
+    @JS var name: String
+    @JS var count: Int
+    @JS var flag: Bool
+    @JS var rate: Float
+    @JS var precise: Double
+
+    @JS init(name: String, count: Int, flag: Bool, rate: Float, precise: Double) {
+        self.name = name
+        self.count = count
+        self.flag = flag
+        self.rate = rate
+        self.precise = precise
+    }
+}
+
+@JS(identityMode: .swift)
+class ClassRoundtripSwiftIdentity {
+    @JS init() {}
+
+    @JS func roundtripSimpleClassSwiftIdentity(_ obj: SimpleClassSwiftIdentity) -> SimpleClassSwiftIdentity {
+        return obj
+    }
+
+    @JS func makeSimpleClassSwiftIdentity() -> SimpleClassSwiftIdentity {
+        return SimpleClassSwiftIdentity(name: "Hello", count: 42, flag: true, rate: 0.5, precise: 3.14159)
+    }
+
+    @JS func takeSimpleClassSwiftIdentity(_ obj: SimpleClassSwiftIdentity) {
+        // consume without returning
+    }
+}
+
+nonisolated(unsafe) var _cachedPoolSwiftIdentity: [SimpleClassSwiftIdentity] = []
+
+@JS(identityMode: .swift)
+class IdentityCacheBenchmarkSwiftIdentity {
+    @JS init() {}
+
+    @JS func setupPool(_ count: Int) {
+        _cachedPoolSwiftIdentity = (0..<count).map {
+            SimpleClassSwiftIdentity(name: "Item \($0)", count: $0, flag: true, rate: 0.5, precise: 3.14)
+        }
+    }
+
+    @JS func getPoolRepeated() -> [SimpleClassSwiftIdentity] {
+        return _cachedPoolSwiftIdentity
+    }
+}
+
 // MARK: - Array Performance Tests
 
 @JS struct Point {