feat: implement superclass method dispatch with new SUPER bytecodes and named call compiler

Add CODE_SUPER_0 through CODE_SUPER_16 bytecodes to the VM for invoking inherited methods, along with a `namedCall` compiler helper that parses method names and argument lists after a dot. The interpreter dispatches super calls by walking up the class hierarchy from the receiver's immediate class, skipping methods defined on that class. Includes three test cases covering calling a different superclass method, calling the same method name, and indirectly inherited methods. Also fixes error formatting to handle newline tokens gracefully and adds a TODO note about not deduplicating placeholder constants for super calls.

test/super/call_other_method.wren

@@ -0,0 +1,22 @@
+class Base {
+  foo {
+    io.write("Base.foo")
+  }
+}
+
+class Derived is Base {
+  bar {
+    io.write("Derived.bar")
+    super.foo
+  }
+}
+
+Derived.new.bar
+// expect: Derived.bar
+// expect: Base.foo
+
+// TODO(bob): Super constructor calls.
+// TODO(bob): Super operator calls.
+// TODO(bob): Calling super outside of a class.
+// TODO(bob): Super calls inside nested functions in methods.
+// TODO(bob): Super where there is no inherited method.

test/super/call_same_method.wren

@@ -0,0 +1,16 @@
+class Base {
+  foo {
+    io.write("Base.foo")
+  }
+}
+
+class Derived is Base {
+  foo {
+    io.write("Derived.foo")
+    super.foo
+  }
+}
+
+Derived.new.foo
+// expect: Derived.foo
+// expect: Base.foo

test/super/indirectly_inherited.wren

@@ -0,0 +1,18 @@
+class A {
+  foo {
+    io.write("A.foo")
+  }
+}
+
+class B is A {}
+
+class C is B {
+  foo {
+    io.write("C.foo")
+    super.foo
+  }
+}
+
+C.new.foo
+// expect: C.foo
+// expect: A.foo