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/analyzer.rs

@@ -178,6 +178,18 @@ impl<'a> Analyzer<'a> {
                 )
             }
 
+            BoundKind::DefDestructure { pattern, value } => {
+                let pat_m = self.visit(Rc::new((**pattern).clone()));
+                let val_m = self.visit(Rc::new((**value).clone()));
+                (
+                    BoundKind::DefDestructure {
+                        pattern: Box::new(pat_m),
+                        value: Box::new(val_m),
+                    },
+                    Purity::Impure,
+                )
+            }
+
             BoundKind::Call { callee, args } => {
                 let callee_m = self.visit(Rc::new((**callee).clone()));
                 let args_m = self.visit(Rc::new((**args).clone()));