fix: implement parameter counting in zrtl_symbol_sig macro

The zrtl_symbol_sig! macro was hardcoded to set param_count=0 for
functions with signature `($($param)*) -> opaque`. This prevented
proper type checking of extern function parameters.

**Changes:**

- Add __count_params! macro to count parameters in signature
- Add __build_param_array! macro to build TypeTag array from params
- Add __fill_param_array! helper to populate parameter types
- Support f32, f64, i32, i64, u32, u64, bool parameter types
- Update zrtl_symbol_sig! to use counted parameters

**Result:**

Plugin signatures now correctly report parameter counts:
- Before: $Tensor$arange_f32 param_count=0
- After: $Tensor$arange_f32 param_count=3

This enables the type checker to create properly typed extern
function declarations with correct parameter lists.

**Example:**
```rust
("$Tensor$arange_f32", tensor_arange_f32, (f32, f32, f32) -> opaque)
```
Now generates a signature with param_count=3 and params=[F32, F32, F32].

Author: darmie

crates/zyntax_embed/src/grammar.rs

@@ -448,6 +448,7 @@ impl LanguageGrammar {
             };
 
             // Create extern function declaration
+            eprintln!("[DEBUG inject_builtin_externs] Creating extern func {} with {} params", target_symbol, params.len());
             let extern_func = TypedFunction {
                 name: InternedString::new_global(target_symbol),
                 type_params: vec![],

sdk/zrtl/src/plugin.rs

@@ -267,11 +267,15 @@ macro_rules! zrtl_symbol_sig {
     // Function with any params that returns opaque pointer
     // Match: (...) -> opaque where ... is anything
     ($name:expr, $func:ident, ($($param:tt)*) -> opaque) => {{
+        // Count and build param array
+        const PARAM_COUNT: u8 = $crate::__count_params!($($param)*);
+        const PARAM_ARRAY: [$crate::TypeTag; $crate::MAX_PARAMS] = $crate::__build_param_array!($($param)*);
+
         static SIG: $crate::ZrtlSymbolSig = $crate::ZrtlSymbolSig {
-            param_count: 0,  // We don't parse param types yet, just mark return as opaque
+            param_count: PARAM_COUNT,
             flags: $crate::ZrtlSigFlags::NONE,
             return_type: $crate::TypeTag::DYNAMIC_BOX,  // Mark as opaque
-            params: [$crate::TypeTag::VOID; $crate::MAX_PARAMS],
+            params: PARAM_ARRAY,
         };
         $crate::ZrtlSymbol::with_sig(
             concat!($name, "\0").as_ptr() as *const ::std::ffi::c_char,
@@ -319,6 +323,95 @@ macro_rules! __count_symbols {
     (($($tt:tt)*) $($rest:tt)*) => { 1 + $crate::__count_symbols!($($rest)*) };
 }
 
+/// Internal helper to count parameters in a signature
+#[macro_export]
+#[doc(hidden)]
+macro_rules! __count_params {
+    () => { 0 };
+    (f32) => { 1 };
+    (f64) => { 1 };
+    (i32) => { 1 };
+    (i64) => { 1 };
+    (u32) => { 1 };
+    (u64) => { 1 };
+    (bool) => { 1 };
+    (f32, $($rest:tt)*) => { 1 + $crate::__count_params!($($rest)*) };
+    (f64, $($rest:tt)*) => { 1 + $crate::__count_params!($($rest)*) };
+    (i32, $($rest:tt)*) => { 1 + $crate::__count_params!($($rest)*) };
+    (i64, $($rest:tt)*) => { 1 + $crate::__count_params!($($rest)*) };
+    (u32, $($rest:tt)*) => { 1 + $crate::__count_params!($($rest)*) };
+    (u64, $($rest:tt)*) => { 1 + $crate::__count_params!($($rest)*) };
+    (bool, $($rest:tt)*) => { 1 + $crate::__count_params!($($rest)*) };
+}
+
+/// Internal helper to build parameter type array
+#[macro_export]
+#[doc(hidden)]
+macro_rules! __build_param_array {
+    () => { [$crate::TypeTag::VOID; $crate::MAX_PARAMS] };
+    ($($param:tt)*) => {{
+        let mut params = [$crate::TypeTag::VOID; $crate::MAX_PARAMS];
+        $crate::__fill_param_array!(params, 0, $($param)*);
+        params
+    }};
+}
+
+/// Internal helper to fill parameter array
+#[macro_export]
+#[doc(hidden)]
+macro_rules! __fill_param_array {
+    ($array:ident, $idx:expr,) => {};
+    ($array:ident, $idx:expr, f32) => {
+        $array[$idx] = $crate::TypeTag::F32;
+    };
+    ($array:ident, $idx:expr, f64) => {
+        $array[$idx] = $crate::TypeTag::F64;
+    };
+    ($array:ident, $idx:expr, i32) => {
+        $array[$idx] = $crate::TypeTag::I32;
+    };
+    ($array:ident, $idx:expr, i64) => {
+        $array[$idx] = $crate::TypeTag::I64;
+    };
+    ($array:ident, $idx:expr, u32) => {
+        $array[$idx] = $crate::TypeTag::U32;
+    };
+    ($array:ident, $idx:expr, u64) => {
+        $array[$idx] = $crate::TypeTag::U64;
+    };
+    ($array:ident, $idx:expr, bool) => {
+        $array[$idx] = $crate::TypeTag::BOOL;
+    };
+    ($array:ident, $idx:expr, f32, $($rest:tt)*) => {
+        $array[$idx] = $crate::TypeTag::F32;
+        $crate::__fill_param_array!($array, $idx + 1, $($rest)*);
+    };
+    ($array:ident, $idx:expr, f64, $($rest:tt)*) => {
+        $array[$idx] = $crate::TypeTag::F64;
+        $crate::__fill_param_array!($array, $idx + 1, $($rest)*);
+    };
+    ($array:ident, $idx:expr, i32, $($rest:tt)*) => {
+        $array[$idx] = $crate::TypeTag::I32;
+        $crate::__fill_param_array!($array, $idx + 1, $($rest)*);
+    };
+    ($array:ident, $idx:expr, i64, $($rest:tt)*) => {
+        $array[$idx] = $crate::TypeTag::I64;
+        $crate::__fill_param_array!($array, $idx + 1, $($rest)*);
+    };
+    ($array:ident, $idx:expr, u32, $($rest:tt)*) => {
+        $array[$idx] = $crate::TypeTag::U32;
+        $crate::__fill_param_array!($array, $idx + 1, $($rest)*);
+    };
+    ($array:ident, $idx:expr, u64, $($rest:tt)*) => {
+        $array[$idx] = $crate::TypeTag::U64;
+        $crate::__fill_param_array!($array, $idx + 1, $($rest)*);
+    };
+    ($array:ident, $idx:expr, bool, $($rest:tt)*) => {
+        $array[$idx] = $crate::TypeTag::BOOL;
+        $crate::__fill_param_array!($array, $idx + 1, $($rest)*);
+    };
+}
+
 /// Macro to define a complete ZRTL plugin
 ///
 /// This creates both the symbol table and plugin info exports.