Implement Local Variables and Closures

Locals and Closures

Local variables live in the current call frame. `LOAD_LOCAL idx` and `STORE_LOCAL idx` are how compiled functions read and write slots without touching the operand stack for every access.

Upvalues and Captured State

A closure captures variables from an enclosing scope. When an inner function references `x` from an outer function, `x` must outlive the outer frame. An upvalue is a cell pointing at that captured variable.

Two common strategies:

• Flat closures: copy captured values into an array on the closure object at creation time
• Linked upvalues: chain through enclosing frames (Lua's real mechanism)

For example, a counter closure might capture `count` from an outer function and increment it each call, even after the outer function returns.

```c typedef struct { int code_address; int upvalue_count; Value* upvalues; } Closure; ```

Whether capture is by copy or by reference is the design choice behind JavaScript's classic loop-variable-in-closure bug.

Design Notes

When a closure escapes, captured variables must live on the heap, not in a stack frame that will disappear. Your flat upvalue array is the minimal version of what Lua and JavaScript runtimes manage with open and closed upvalue lists.

For This Exercise

This exercise asks you to wire locals into frames and add flat closures with `OP_CLOSURE`. You will implement `LOAD_UPVALUE` and `STORE_UPVALUE` so a nested function reads a captured variable after the outer frame is gone.