feat: Add multi-language runtime support to zyntax_embed

Add grammar registry and load_module API to both ZyntaxRuntime and
TieredRuntime for polyglot application support:

New methods:
- register_grammar(language, grammar) - Register grammar by language ID
- register_grammar_file(language, path) - Compile and register from .zyn
- register_grammar_zpeg(language, path) - Load and register from .zpeg
- get_grammar(language) - Retrieve registered grammar
- languages() - List all registered languages
- has_language(language) - Check if language is registered
- language_for_extension(ext) - Get language for file extension
- load_module(language, source) - Parse and compile by language
- load_module_file(path) - Load with auto-detected language
- functions() - List all loaded function names
- has_function(name) - Check if function exists

Usage:
  runtime.register_grammar("zig", grammar)?;
  runtime.load_module("zig", "pub fn add(a: i32, b: i32) i32 { ... }")?;
  runtime.load_module_file("./src/math.zig")?; // Auto-detect from extension

Author: darmie

book/12-embedding-sdk.md

@@ -7,6 +7,7 @@ This chapter covers how to embed the Zyntax JIT runtime in your Rust application
 The Zyntax Embedding SDK provides:
 
 - **Language Grammar Interface**: Parse source code using any `.zyn` grammar
+- **Multi-Language Runtime**: Register multiple grammars and compile from different languages
 - **JIT Compilation**: Compile TypedAST to native code at runtime
 - **Multi-Tier Optimization**: Automatic optimization of hot code paths
 - **Bidirectional Interop**: Seamless conversion between Rust and Zyntax types
@@ -132,6 +133,113 @@ impl AstHostFunctions for MyCustomBuilder {
 }
 ```
 
+## Multi-Language Runtime
+
+The runtime supports registering multiple language grammars and loading modules by language name. This enables polyglot applications where different parts of your codebase can use different languages.
+
+### Registering Grammars
+
+```rust
+use zyntax_embed::{ZyntaxRuntime, LanguageGrammar};
+
+let mut runtime = ZyntaxRuntime::new()?;
+
+// Register grammars by language name
+runtime.register_grammar("zig", LanguageGrammar::compile_zyn_file("grammars/zig.zyn")?);
+runtime.register_grammar("python", LanguageGrammar::compile_zyn_file("grammars/python.zyn")?);
+runtime.register_grammar("calc", LanguageGrammar::compile_zyn_file("grammars/calc.zyn")?);
+
+// Or use convenience methods
+runtime.register_grammar_file("haxe", "grammars/haxe.zyn")?;
+runtime.register_grammar_zpeg("lua", "grammars/lua.zpeg")?;
+
+// Query registered languages
+println!("Languages: {:?}", runtime.languages());       // ["zig", "python", "calc", "haxe", "lua"]
+println!("Has Python: {}", runtime.has_language("python")); // true
+```
+
+### Loading Modules by Language
+
+```rust
+// Load modules specifying the language
+let functions = runtime.load_module("zig", r#"
+    pub fn add(a: i32, b: i32) i32 {
+        return a + b;
+    }
+
+    pub fn factorial(n: i32) i32 {
+        if (n <= 1) return 1;
+        return n * factorial(n - 1);
+    }
+"#)?;
+
+println!("Loaded functions: {:?}", functions); // ["add", "factorial"]
+
+// Load from another language
+runtime.load_module("calc", "def multiply(a, b) = a * b")?;
+
+// Call any function regardless of source language
+let sum: i32 = runtime.call("add", &[10.into(), 32.into()])?;
+let fact: i32 = runtime.call("factorial", &[5.into()])?;
+```
+
+### Auto-Detection from File Extension
+
+When grammars declare file extensions in their `@language` metadata, the runtime automatically maps extensions to languages:
+
+```rust
+// The zig.zyn grammar declares: file_extensions: [".zig"]
+runtime.register_grammar("zig", LanguageGrammar::compile_zyn_file("zig.zyn")?);
+
+// Load files - language auto-detected from extension
+runtime.load_module_file("./src/math.zig")?;   // Uses "zig" grammar
+runtime.load_module_file("./lib/utils.py")?;   // Uses "python" grammar
+
+// Query extension mappings
+println!("Language for .zig: {:?}", runtime.language_for_extension(".zig")); // Some("zig")
+println!("Language for .py: {:?}", runtime.language_for_extension("py"));    // Some("python")
+```
+
+### Cross-Language Function Calls
+
+All modules loaded into the same runtime share a common execution environment. Functions can call each other across language boundaries:
+
+```rust
+// Load core utilities in Zig
+runtime.load_module("zig", r#"
+    pub fn square(x: i32) i32 { return x * x; }
+    pub fn cube(x: i32) i32 { return x * x * x; }
+"#)?;
+
+// Load a DSL that uses the Zig functions via extern declarations
+runtime.load_module("calc", r#"
+    extern fn square(x: i32) i32;
+    extern fn cube(x: i32) i32;
+
+    def sum_of_powers(a, b) = square(a) + cube(b)
+"#)?;
+
+// The calc function calls into the Zig implementation
+let result: i32 = runtime.call("sum_of_powers", &[3.into(), 2.into()])?;
+assert_eq!(result, 17); // square(3) + cube(2) = 9 + 8 = 17
+```
+
+### TieredRuntime Multi-Language Support
+
+The `TieredRuntime` also supports multi-language modules with the same API:
+
+```rust
+use zyntax_embed::TieredRuntime;
+
+let mut runtime = TieredRuntime::production()?;
+
+runtime.register_grammar("zig", LanguageGrammar::compile_zyn_file("zig.zyn")?);
+runtime.load_module("zig", "pub fn compute(x: i32) i32 { return x * 2; }")?;
+
+// Hot functions are automatically optimized regardless of source language
+let result: i32 = runtime.call("compute", &[21.into()])?;
+```
+
 ## Runtime Options
 
 ### ZyntaxRuntime (Single-Tier JIT)

crates/zyntax_embed/README.md

@@ -11,6 +11,7 @@ Apache-2.0
 `zyntax_embed` provides a high-level Rust API for embedding the Zyntax compiler as a JIT runtime. It supports:
 
 - **Language Grammar Interface**: Parse source code using any `.zyn` grammar
+- **Multi-Language Runtime**: Register multiple grammars and compile from different languages
 - **Compiler Integration**: Compile and execute Zyntax code at runtime
 - **Multi-Tier JIT**: Automatic optimization of hot code paths
 - **Async/Await**: Promise-based async operations with `.then()` and `.catch()`
@@ -118,6 +119,74 @@ let json = grammar.parse_to_json(source_code)?;
 println!("{}", json);
 ```
 
+## Multi-Language Runtime
+
+Register multiple language grammars and load modules by language name:
+
+```rust
+use zyntax_embed::{ZyntaxRuntime, LanguageGrammar};
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let mut runtime = ZyntaxRuntime::new()?;
+
+    // Register language grammars
+    runtime.register_grammar("zig", LanguageGrammar::compile_zyn_file("grammars/zig.zyn")?);
+    runtime.register_grammar("python", LanguageGrammar::compile_zyn_file("grammars/python.zyn")?);
+    runtime.register_grammar("calc", LanguageGrammar::compile_zyn_file("grammars/calc.zyn")?);
+
+    // Load modules by language name
+    runtime.load_module("zig", r#"
+        pub fn add(a: i32, b: i32) i32 {
+            return a + b;
+        }
+    "#)?;
+
+    runtime.load_module("calc", "def multiply(a, b) = a * b")?;
+
+    // Call functions from any loaded module
+    let sum: i32 = runtime.call("add", &[10.into(), 32.into()])?;
+    println!("Sum: {}", sum); // 42
+
+    Ok(())
+}
+```
+
+### Auto-detection from File Extension
+
+```rust
+// Register grammars (extensions are auto-detected from grammar metadata)
+runtime.register_grammar("zig", LanguageGrammar::compile_zyn_file("zig.zyn")?);
+
+// Load files - language detected from extension
+runtime.load_module_file("./src/math.zig")?;   // Uses "zig" grammar
+runtime.load_module_file("./src/utils.py")?;   // Uses "python" grammar
+
+// Query registered languages
+println!("Languages: {:?}", runtime.languages());
+println!("Language for .zig: {:?}", runtime.language_for_extension(".zig"));
+```
+
+### Cross-Language Interop
+
+Functions from different languages share the same runtime and can call each other:
+
+```rust
+// Load math utilities in Zig
+runtime.load_module("zig", r#"
+    pub fn square(x: i32) i32 { return x * x; }
+"#)?;
+
+// Load DSL that uses the Zig function
+runtime.load_module("calc", r#"
+    extern fn square(x: i32) i32;
+    def sum_of_squares(a, b) = square(a) + square(b)
+"#)?;
+
+// Call the DSL function that internally uses Zig
+let result: i32 = runtime.call("sum_of_squares", &[3.into(), 4.into()])?;
+assert_eq!(result, 25); // 9 + 16
+```
+
 ## Runtime Options
 
 ### ZyntaxRuntime (Simple JIT)