Refactor Binder to support recursion and add stdlib operators

This commit introduces two main changes:

1.  **Binder Refactoring**: The `Binder` has been refactored to support
    recursive definitions by pre-declaring names in the scope before
    binding their values. This ensures that a name is visible to itself
    when its definition is being processed.

2.  **Stdlib Operator Implementation**: Several standard library
    operators, including `+`, `-`, `*`, `/`, `>`, and `<`, have been
    implemented. These operators now correctly handle both `Int` and
    `Float` types for numerical operations and comparisons.
    Additionally, the display formatting for `Value::List` and
    `Value::Record` has been improved for better readability. The
    default source code in `main.rs` has also been updated to include a
    Fibonacci example, demonstrating the new recursive capabilities.

src/ast/types.rs

@@ -126,8 +126,22 @@ impl fmt::Display for Value {
             Value::Float(fl) => write!(f, "{}", fl),
             Value::Text(t) => write!(f, "\"{}\"", t),
             Value::Keyword(k) => write!(f, ":{}", k.name()),
-            Value::List(l) => write!(f, "<list[{}]>", l.len()),
-            Value::Record(r) => write!(f, "<record[{}]>", r.len()),
+            Value::List(l) => {
+                write!(f, "[")?;
+                for (i, val) in l.iter().enumerate() {
+                    if i > 0 { write!(f, " ")?; }
+                    write!(f, "{}", val)?;
+                }
+                write!(f, "]")
+            },
+            Value::Record(r) => {
+                write!(f, "{{")?;
+                for (i, (k, v)) in r.iter().enumerate() {
+                    if i > 0 { write!(f, ", ")?; }
+                    write!(f, ":{} {}", k.name(), v)?;
+                }
+                write!(f, "}}")
+            },
             Value::Function(_) => write!(f, "<native fn>"),
             Value::Object(o) => write!(f, "<{}>", o.type_name()),
             Value::Cell(c) => write!(f, "{}", c.borrow()),