feat: implement static methods as local variables in implicit class scope

Refactor the compiler to treat static methods as local variables defined in an implicit scope surrounding the class, eliminating the need for VM-level static method support. This changes `declareVariable` to use the previously consumed token, adds `declareNamedVariable` for explicit token consumption, and updates `parameterList` to use the new function. Adjusts VM bytecode ordering for `CODE_METHOD_INSTANCE` and `CODE_METHOD_STATIC` to pop the class before the function body. Adds comprehensive test coverage for static fields including closures, nested classes, default null values, instance method access, and error cases for field usage outside classes or in static methods.

test/static_field/closure.wren

@@ -0,0 +1,16 @@
+class Foo {
+  static initialize { __field = "Foo field" }
+
+  static closeOverGet {
+    return fn { return __field }
+  }
+
+  static closeOverSet {
+    return fn { __field = "new value" }
+  }
+}
+
+Foo.initialize
+IO.print(Foo.closeOverGet.call) // expect: Foo field
+Foo.closeOverSet.call
+IO.print(Foo.closeOverGet.call) // expect: new value

test/static_field/default_to_null.wren

@@ -0,0 +1,5 @@
+class Foo {
+  static write { IO.print(__field) }
+}
+
+Foo.write // expect: null

test/static_field/in_instance_method.wren

@@ -0,0 +1,25 @@
+class Foo {
+  set(a, b, c, d, e) {
+    __a = a
+    __b = b
+    __c = c
+    __d = d
+    __e = e
+  }
+
+  write {
+    IO.print(__a)
+    IO.print(__b)
+    IO.print(__c)
+    IO.print(__d)
+    IO.print(__e)
+  }
+}
+
+(new Foo).set(1, 2, 3, 4, 5)
+(new Foo).write
+// expect: 1
+// expect: 2
+// expect: 3
+// expect: 4
+// expect: 5

test/static_field/multiple.wren

@@ -0,0 +1,25 @@
+class Foo {
+  static set(a, b, c, d, e) {
+    __a = a
+    __b = b
+    __c = c
+    __d = d
+    __e = e
+  }
+
+  static write {
+    IO.print(__a)
+    IO.print(__b)
+    IO.print(__c)
+    IO.print(__d)
+    IO.print(__e)
+  }
+}
+
+Foo.set(1, 2, 3, 4, 5)
+Foo.write
+// expect: 1
+// expect: 2
+// expect: 3
+// expect: 4
+// expect: 5

test/static_field/nested_class.wren

@@ -0,0 +1,34 @@
+class Outer {
+  static staticMethod {
+    __field = "outer"
+    IO.print(__field) // expect: outer
+
+    class Inner {
+      static staticMethod {
+        __field = "inner"
+        IO.print(__field) // expect: inner
+      }
+    }
+
+    Inner.staticMethod
+    IO.print(__field) // expect: outer
+  }
+
+  instanceMethod {
+    __field = "outer"
+    IO.print(__field) // expect: outer
+
+    class Inner {
+      instanceMethod {
+        __field = "inner"
+        IO.print(__field) // expect: inner
+      }
+    }
+
+    (new Inner).instanceMethod
+    IO.print(__field) // expect: outer
+  }
+}
+
+Outer.staticMethod
+(new Outer).instanceMethod

test/static_field/outside_class.wren

@@ -0,0 +1 @@
+__field = "wat" // expect error

test/static_field/use_before_set.wren

@@ -0,0 +1,8 @@
+class Foo {
+  static write { IO.print(__field) } // Compile a use of the field...
+  static init { __field = "value" }  // ...before an assignment to it.
+}
+
+// But invoke them in the right order.
+Foo.init
+Foo.write // expect: value