Refactor: Use Value::Closure enum variant

Previously, compiled closures were stored as `Value::Object` and then
downcasted. This commit introduces a dedicated `Value::Closure` enum
variant to represent compiled closures. This improves type safety and
simplifies handling of closures throughout the compiler and VM.

This change involves:
- Updating type definitions to use `Value::Closure`.
- Adjusting downcasting logic to directly access the `Closure` struct.
- Modifying `run_with_args` and `run_with_args_observed` to expect
  `Value::Closure` for tail-call targets.
- Refining the handling of closures in the `Optimizer` and `Inliner` for
  better type clarity.

src/ast/types.rs

@@ -1,3 +1,4 @@
+use crate::ast::closure::Closure;
 use chrono::{TimeZone, Utc};
 use std::any::Any;
 use std::cell::RefCell;
@@ -257,7 +258,8 @@ pub enum Value {
     Record(std::sync::Arc<RecordLayout>, ValueList),
     FieldAccessor(Keyword),
     Function(Rc<NativeFunction>),
-    Object(Rc<dyn Object>),   // For compiled Closures and other opaque types
+    Closure(Rc<Closure>),     // Compiled function with captured upvalues
+    Object(Rc<dyn Object>),   // For Series, Streams, SyntaxNodes, and custom extensions
     Cell(Rc<RefCell<Value>>), // Boxed value for captures
 }
 
@@ -277,6 +279,7 @@ impl PartialEq for Value {
             }
             (Value::FieldAccessor(a), Value::FieldAccessor(b)) => a == b,
             (Value::Function(a), Value::Function(b)) => Rc::ptr_eq(a, b),
+            (Value::Closure(a), Value::Closure(b)) => Rc::ptr_eq(a, b),
             (Value::Object(a), Value::Object(b)) => Rc::ptr_eq(a, b),
             (Value::Cell(a), Value::Cell(b)) => Rc::ptr_eq(a, b),
             _ => false,
@@ -617,6 +620,7 @@ impl Value {
             Value::Record(layout, _) => StaticType::Record(layout.clone()),
             Value::FieldAccessor(k) => StaticType::FieldAccessor(*k),
             Value::Function(_) => StaticType::Any, // Dynamic function
+            Value::Closure(_) => StaticType::Object("closure"),
             Value::Object(o) => StaticType::Object(o.type_name()),
             Value::Cell(c) => c.borrow().static_type(),
         }
@@ -660,6 +664,7 @@ impl fmt::Display for Value {
             }
             Value::FieldAccessor(k) => write!(f, ".{}", k.name()),
             Value::Function(f_meta) => write!(f, "<native fn, {:?}>", f_meta.purity),
+            Value::Closure(_) => write!(f, "<closure>"),
             Value::Object(o) => write!(f, "<{:?}>", o),
             Value::Cell(c) => write!(f, "{}", c.borrow()),
         }