feat: add fromFileURL API for cross-platform file:// URL support

Adds `fromFileURL()` method to RiveFileFactory for loading .riv files from local file:// URLs on both iOS and Android.

**Changes:**
- Add `fromFileURL` to RiveFile.nitro.ts spec
- Implement `fromFileURL` in iOS (HybridRiveFileFactory.swift)
  - Validates file:// URL scheme
  - Loads data from local file path
  - Runs on background thread (userInitiated QoS)
- Implement `fromFileURL` in Android (HybridRiveFileFactory.kt)
  - Validates file:// URL scheme (matches iOS behavior)
  - Converts URI to file path using java.net.URI
  - Loads file on Dispatchers.IO background thread
- Update `fromSource()` to use `fromFileURL()` for file:// URLs
  - Previously tried to parse resource name from path (fragile)
  - Now directly loads from file URL (more robust)
- Regenerate Nitrogen boilerplate

**Fixes:** Resolves production mode issue where iOS bundled assets resolve to file:// URLs instead of resource names, which was causing "Could not find Rive file" errors.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

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

Author: mfazekas

android/src/main/java/com/margelo/nitro/rive/HybridRiveFileFactory.kt

@@ -9,6 +9,8 @@ import com.margelo.nitro.core.Promise
 import com.margelo.nitro.NitroModules
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
+import java.io.File as JavaFile
+import java.net.URI
 import java.net.URL
 
 @Keep
@@ -33,6 +35,31 @@ class HybridRiveFileFactory : HybridRiveFileFactorySpec() {
     }
   }
 
+  override fun fromFileURL(fileURL: String, loadCdn: Boolean): Promise<HybridRiveFileSpec> {
+    if (!fileURL.startsWith("file://")) {
+      throw Error("fromFileURL: URL must be a file URL: $fileURL")
+    }
+
+    return Promise.async {
+      try {
+        val uri = URI(fileURL)
+        val path = uri.path ?: throw Error("fromFileURL: Invalid URL: $fileURL")
+
+        val riveFile = withContext(Dispatchers.IO) {
+          val file = JavaFile(path)
+          val riveData = file.readBytes()
+          File(riveData)
+        }
+
+        val hybridRiveFile = HybridRiveFile()
+        hybridRiveFile.riveFile = riveFile
+        hybridRiveFile
+      } catch (e: Exception) {
+        throw Error("Failed to load Rive file: ${e.message}")
+      }
+    }
+  }
+
   @SuppressLint("DiscouragedApi")
   override fun fromResource(resource: String, loadCdn: Boolean): Promise<HybridRiveFileSpec> {
     return Promise.async {

ios/HybridRiveFileFactory.swift

@@ -38,6 +38,45 @@ class HybridRiveFileFactory: HybridRiveFileFactorySpec {
     }
   }
 
+  func fromFileURL(fileURL: String, loadCdn: Bool) throws -> Promise<(any HybridRiveFileSpec)> {
+    guard let url = URL(string:fileURL) else {
+      throw RuntimeError.error(withMessage: "fromFileURL: Invalid URL: \(fileURL)")
+    }
+    
+    guard url.isFileURL else {
+      throw RuntimeError.error(withMessage: "fromFileURL: URL must be a file URL: \(fileURL)")
+    }
+    
+    return Promise.async {
+      do {
+        let riveFile = try await withCheckedThrowingContinuation { continuation in
+          DispatchQueue.global(qos: .userInitiated).async {
+            do {
+              let data = try Data(contentsOf: url)
+              
+              let riveFile = try RiveFile(data: data, loadCdn: loadCdn)
+              DispatchQueue.main.async {
+                continuation.resume(returning: riveFile)
+              }
+            } catch {
+              DispatchQueue.main.async {
+                continuation.resume(throwing: error)
+              }
+            }
+          }
+        }
+        
+        let hybridRiveFile = HybridRiveFile()
+        hybridRiveFile.riveFile = riveFile
+        return hybridRiveFile
+      } catch let error as NSError {
+        throw RuntimeError.error(withMessage: "Failed to load Rive file: \(error.localizedDescription)")
+      } catch {
+        throw RuntimeError.error(withMessage: "Unknown error occurred while loading Rive file")
+      }
+    }
+  }
+  
   func fromResource(resource: String, loadCdn: Bool) throws -> Promise<(any HybridRiveFileSpec)> {
     guard let _ = Bundle.main.path(forResource: resource, ofType: "riv") else {
       throw RuntimeError.error(withMessage: "Could not find Rive file: \(resource).riv")