- Adjust Environment to use BoundNode for the function registry and

correctly initialize the `TypeChecker` with argument types during
  macro expansion.
- Refactor `Specializer::compile` to perform type checking with provided
  arguments before specialization and to correctly extract the return
  type.
- Enhance the `Dumper` to introspect and display specialized closure
  bodies.
- Update `LambdaCollector` to use `BoundNode` consistently.
- Modify `TypeChecker` to accept and inject specialized argument types
  for lambdas.

src/ast/compiler/specializer.rs

@@ -2,7 +2,7 @@ use std::collections::HashMap;
 use std::rc::Rc;
 use std::cell::RefCell;
 use crate::ast::types::{StaticType, Value, Signature};
-use crate::ast::compiler::bound_nodes::{BoundKind, Address, TypedNode};
+use crate::ast::compiler::bound_nodes::{BoundKind, Address, TypedNode, BoundNode};
 use crate::ast::nodes::Node;
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -11,11 +11,11 @@ pub struct MonoCacheKey {
     pub arg_types: Vec<StaticType>,
 }
 
-pub type CompileFunc = Rc<dyn Fn(TypedNode, &[StaticType]) -> Result<(Value, StaticType), String>>;
+pub type CompileFunc = Rc<dyn Fn(BoundNode, &[StaticType]) -> Result<(Value, StaticType), String>>;
 pub type RtlLookupFunc = Rc<dyn Fn(&str, &[StaticType]) -> Option<(Value, StaticType)>>;
 
 pub trait FunctionRegistry {
-    fn resolve(&self, addr: Address) -> Option<TypedNode>;
+    fn resolve(&self, addr: Address) -> Option<BoundNode>;
 }
 
 pub type MonoCache = HashMap<MonoCacheKey, (Value, StaticType)>;
@@ -182,18 +182,21 @@ impl Specializer {
             if let Some(compiler) = &self.compiler {
                 match compiler(func_node, &arg_types) {
                     Ok((compiled_val, ret_ty)) => {
+                        let res_val: Value = compiled_val;
+                        let res_ty: StaticType = ret_ty;
+                        
                         // Store in cache
-                        self.cache.borrow_mut().insert(key, (compiled_val.clone(), ret_ty.clone()));
+                        self.cache.borrow_mut().insert(key, (res_val.clone(), res_ty.clone()));
 
                         let specialized_callee = Node {
                             identity: new_callee.identity.clone(),
-                            kind: BoundKind::Constant(compiled_val),
+                            kind: BoundKind::Constant(res_val),
                             ty: StaticType::Function(Box::new(Signature {
                                 params: arg_types,
-                                ret: ret_ty.clone(),
+                                ret: res_ty.clone(),
                             })),
                         };
-                        return (specialized_callee, new_args, ret_ty);
+                        return (specialized_callee, new_args, res_ty);
                     },
                     Err(_) => {
                         // Fallback on error