feat: Add StaticType and type checking

This commit introduces `StaticType` and enhances the `Binder` to perform
basic type checking during the binding phase.

Key changes include:

- **`StaticType` enum:** Represents static types such as `Any`, `Void`,
  `Bool`, `Int`, `Float`, `Text`, `List`, `Record`, and `Function`.
- **`Node<K, T>`:** The generic `Node` now includes a `ty` field to
  store its inferred static type.
- **Binder enhancements:**
    - `CompilerScope` now stores `LocalInfo` containing the variable's
      slot and `StaticType`.
    - `FunctionCompiler` stores upvalues with their associated
      `StaticType`.
    - `Binder::bind` now returns `Node<BoundKind, StaticType>`,
      propagating type information.
    - Type checking is added for `If` conditions and `Assign`
      operations.
    - `Def` nodes now infer and store the type of the defined variable.
- **`Value::static_type()`:** A new method to determine the `StaticType`
  of a `Value`.
- **Environment modifications:** `global_names` now stores `(u32,
  StaticType)` to associate global variables with their types.
- **Parser modifications:** The `ty` field of nodes is initialized to
  `()` by default.
- **VM modifications:** `VM::run` and `VM::eval` now operate on
  `Node<BoundKind, StaticType>`.
- **Tests:** Added basic evaluation and type error tests.
  feat: Add StaticType and type checking

Introduces `StaticType` enum and integrates it into the AST. The binder
now performs type checking during compilation, ensuring that expressions
conform to expected types, especially for control flow structures like
`if`. This lays the groundwork for static type analysis and error
reporting.

src/main.rs

@@ -117,3 +117,33 @@ impl eframe::App for CompilerApp {
         });
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::ast::types::Value;
+
+    #[test]
+    fn test_basic_eval() {
+        let env = Environment::new();
+        let result = env.run_script("(+ 1 2)").unwrap();
+        if let Value::Int(i) = result {
+            assert_eq!(i, 3);
+        } else if let Value::Float(f) = result {
+            assert_eq!(f, 3.0);
+        } else {
+            panic!("Expected number result");
+        }
+    }
+
+    #[test]
+    fn test_type_error() {
+        let env = Environment::new();
+        // This should fail because 'if' condition must be bool (and currently '+' returns Any/Float/Int)
+        // Wait, '+' returns Any currently in my registration.
+        // Let's try something that definitely fails type check.
+        let result = env.run_script("(if 1 2 3)");
+        assert!(result.is_err());
+        assert!(result.unwrap_err().contains("Condition must be boolean"));
+    }
+}