boot: methods (fn T.m, self by address, mutation analysis), str() of any value

Methods are functions whose first parameter is the receiver's address; a method
that changes self can't be called on a temporary or a read-only value, and
calling one on a variable keeps a parameter from being borrowed. An argument
that lives inside the receiver is copied (c.merge(c)). str(x) and print of
arrays and structs go through one formatter, as in the C++ compiler.

boot.sh: 12 passed, 0 failed, 10 skipped.

tests/run/methods_basic.fch

@@ -0,0 +1,88 @@
+
+struct Counter {
+    str name
+    int count
+    []int history
+}
+
+fn Counter.add(int n) {
+    self.count += n
+    self.history.push(n)
+}
+
+fn Counter.add_twice(int n) {
+    self.add(n)        // a method calling another method on self
+    self.add(n)
+}
+
+fn Counter.total() -> int {
+    sum := 0
+    for x in self.history {
+        sum += x
+    }
+    return sum
+}
+
+fn Counter.describe() -> str {
+    return self.name + ": " + str(self.count) + " " + str(self.history)
+}
+
+fn Counter.copy_named(str name) -> Counter {
+    c := self          // a copy of the struct, not the original
+    c.name = name
+    return c
+}
+
+fn Counter.merge(Counter other) {
+    for x in other.history {
+        self.add(x)
+    }
+}
+
+struct Node {
+    int value
+    ptr[Node] next
+}
+
+fn Node.sum() -> int {
+    total := self.value
+    if self.next != null {
+        total += self.next.sum()   // through a pointer
+    }
+    return total
+}
+
+
+fn main() {
+    c := Counter(name: "clicks")
+    c.add(3)
+    c.add_twice(2)
+    print(c.describe(), c.total())
+
+    d := c.copy_named("copy")
+    d.add(10)
+    print(c.describe())
+    print(d.describe())
+
+    c.merge(c)         // the argument lives inside self: the method gets its own copy
+    print(c.describe())
+
+    []Counter all = [Counter(name: "a"), Counter(name: "b")]
+    all[1].add(7)
+    for i in 0..all.len {
+        all[i].add(i)
+    }
+    print(all[0].describe(), "|", all[1].describe())
+
+    print(Counter(name: "temp", count: 5).describe())
+
+    last := new(Node(3, null))
+    first := new(Node(1, new(Node(2, last))))
+    print(first.sum())
+    p := first.next
+    p.value = 20
+    print(first.sum(), p.sum())
+    free(last)
+    free(first.next)
+    free(first)
+}