refactor: move benchmark directory under test and update all references

The benchmark directory is relocated from the project root into the test directory, and all scripts, documentation links, and gitignore paths are updated accordingly. The test runner is also refactored to explicitly walk subdirectories (core, io, language, limit) instead of using a single test root, and a new test/README.md is added to document the test suite structure. Additionally, the constructor test for the Foo class is updated to add a zero-arity constructor and adjust expected output strings.

test/language/closure/assign_to_closure.wren

@@ -0,0 +1,25 @@
+var f = null
+var g = null
+
+{
+  var local = "local"
+  f = new Fn {
+    IO.print(local)
+    local = "after f"
+    IO.print(local)
+  }
+
+  g = new Fn {
+    IO.print(local)
+    local = "after g"
+    IO.print(local)
+  }
+}
+
+f.call()
+// expect: local
+// expect: after f
+
+g.call()
+// expect: after f
+// expect: after g

test/language/closure/close_over_function_parameter.wren

@@ -0,0 +1,9 @@
+var f = null
+
+new Fn {|param|
+  f = new Fn {
+    IO.print(param)
+  }
+}.call("param")
+
+f.call() // expect: param

test/language/closure/close_over_later_variable.wren

@@ -0,0 +1,13 @@
+// This is a regression test. There was a bug where if an upvalue for an
+// earlier local (here "a") was captured *after* a later one ("b"), then Wren
+// would crash because it walked to the end of the upvalue list (correct), but
+// then didn't handle not finding the variable.
+
+new Fn {
+  var a = "a"
+  var b = "b"
+  new Fn {
+    IO.print(b) // expect: b
+    IO.print(a) // expect: a
+  }.call()
+}.call()

test/language/closure/close_over_method_parameter.wren

@@ -0,0 +1,12 @@
+var F = null
+
+class Foo {
+  method(param) {
+    F = new Fn {
+      IO.print(param)
+    }
+  }
+}
+
+(new Foo).method("param")
+F.call() // expect: param

test/language/closure/closed_closure_in_function.wren

@@ -0,0 +1,10 @@
+var f = null
+
+{
+  var local = "local"
+  f = new Fn {
+    IO.print(local)
+  }
+}
+
+f.call() // expect: local

test/language/closure/closed_closure_in_method.wren

@@ -0,0 +1,14 @@
+var foo = null
+
+{
+  var local = "local"
+  class Foo {
+    method {
+      IO.print(local)
+    }
+  }
+
+  foo = new Foo
+}
+
+foo.method // expect: local

test/language/closure/nested_closure.wren

@@ -0,0 +1,21 @@
+var f = null
+
+new Fn {
+  var a = "a"
+  new Fn {
+    var b = "b"
+    new Fn {
+      var c = "c"
+      f = new Fn {
+        IO.print(a)
+        IO.print(b)
+        IO.print(c)
+      }
+    }.call()
+  }.call()
+}.call()
+
+f.call()
+// expect: a
+// expect: b
+// expect: c

test/language/closure/open_closure_in_function.wren

@@ -0,0 +1,6 @@
+{
+  var local = "local"
+  new Fn {
+    IO.print(local) // expect: local
+  }.call()
+}

test/language/closure/open_closure_in_method.wren

@@ -0,0 +1,10 @@
+{
+  var local = "local"
+  class Foo {
+    method {
+      IO.print(local)
+    }
+  }
+
+  (new Foo).method // expect: local
+}

test/language/closure/reference_closure_multiple_times.wren

@@ -0,0 +1,13 @@
+var f = null
+
+{
+  var a = "a"
+  f = new Fn {
+    IO.print(a)
+    IO.print(a)
+  }
+}
+
+f.call()
+// expect: a
+// expect: a

test/language/closure/reuse_closure_slot.wren

@@ -0,0 +1,17 @@
+{
+  var f = null
+
+  {
+    var a = "a"
+    f = new Fn { IO.print(a) }
+  }
+
+  {
+    // Since a is out of scope, the local slot will be reused by b. Make sure
+    // that f still closes over a.
+    var b = "b"
+    f.call() // expect: a
+  }
+}
+
+// TODO: Maximum number of closed-over variables (directly and/or indirect).

test/language/closure/shadow_closure_with_local.wren

@@ -0,0 +1,11 @@
+{
+  var foo = "closure"
+  new Fn {
+    {
+      IO.print(foo) // expect: closure
+      var foo = "shadow"
+      IO.print(foo) // expect: shadow
+    }
+    IO.print(foo) // expect: closure
+  }.call()
+}