feat: C backend module import support, Int/Float.toString, Test.assertEqualMsg

The C backend can now compile programs that import user-defined modules.
Module-qualified calls like `mymodule.func(args)` are resolved to prefixed
C functions (e.g., `mymodule_func_lux`), with full support for transitive
imports and effect-passing. Also adds Int.toString/Float.toString to type
system, interpreter, and C backend, and Test.assertEqualMsg for labeled
test assertions.

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

src/types.rs

@@ -1146,6 +1146,15 @@ impl TypeEnv {
                         ],
                         return_type: Type::Unit,
                     },
+                    EffectOpDef {
+                        name: "assertEqualMsg".to_string(),
+                        params: vec![
+                            ("expected".to_string(), Type::Var(0)),
+                            ("actual".to_string(), Type::Var(0)),
+                            ("label".to_string(), Type::String),
+                        ],
+                        return_type: Type::Unit,
+                    },
                     EffectOpDef {
                         name: "assertNotEqual".to_string(),
                         params: vec![
@@ -1881,6 +1890,24 @@ impl TypeEnv {
         ]);
         env.bind("Math", TypeScheme::mono(math_module_type));
 
+        // Int module
+        let int_module_type = Type::Record(vec![
+            (
+                "toString".to_string(),
+                Type::function(vec![Type::Int], Type::String),
+            ),
+        ]);
+        env.bind("Int", TypeScheme::mono(int_module_type));
+
+        // Float module
+        let float_module_type = Type::Record(vec![
+            (
+                "toString".to_string(),
+                Type::function(vec![Type::Float], Type::String),
+            ),
+        ]);
+        env.bind("Float", TypeScheme::mono(float_module_type));
+
         env
     }