Add support for destructuring def

This commit introduces the `DefDestructure` bound kind and modifies the
binder, analyzer, type checker, and VM to support destructuring in `def`
statements. This allows for pattern matching on the right-hand side of a
`def` to bind multiple variables.

The parser has been updated to accept patterns in `def` statements. The
binder now handles `UntypedKind::Def` with a `target` pattern, rather
than a simple `name`. This enables destructuring.

The `Gemini.md` documentation has been updated to include a new rule for
incremental development.

src/ast/compiler/bound_nodes.rs

@@ -82,6 +82,12 @@ pub enum BoundKind<T = ()> {
         value: Box<BoundNode<T>>,
     },
 
+    /// A destructuring definition (can be local or global depending on the pattern)
+    DefDestructure {
+        pattern: Box<BoundNode<T>>,
+        value: Box<BoundNode<T>>,
+    },
+
     Lambda {
         params: Rc<BoundNode<T>>,
         // The list of variables captured from enclosing scopes
@@ -187,6 +193,16 @@ where
                     value: vb,
                 },
             ) => na == nb && ga == gb && va == vb,
+            (
+                BoundKind::DefDestructure {
+                    pattern: pa,
+                    value: va,
+                },
+                BoundKind::DefDestructure {
+                    pattern: pb,
+                    value: vb,
+                },
+            ) => pa == pb && va == vb,
             (
                 BoundKind::Lambda {
                     params: pa,
@@ -249,6 +265,7 @@ impl<T> BoundKind<T> {
             BoundKind::DefGlobal {
                 name, global_index, ..
             } => format!("DEF_GLOBAL({}, Idx:{})", name.name, global_index),
+            BoundKind::DefDestructure { .. } => "DEF_DESTRUCTURE".to_string(),
             BoundKind::Lambda {
                 params, upvalues, ..
             } => {