feat: type checking for functions

[leonidas1712]

• All parameters must have type annotations
• Type and length of arguments match function
• Nested return statements applying to the current function must have same type as return type annotation
• Add type annotations for higher order fn, semaphore, string
• [ ] Polymorphic join return (might leave out)

Function is well-typed iff:

1. all nested return stmts belonging to the function return the same type as the return type annotation, AND
2. Somewhere in the block we encounter a terminating statement OR the last expression of the block has the same type as the return type

Similar to Go spec: https://go.dev/ref/spec#Terminating_statements

Higher order function annotations look like this:

fn apply(f: fn(int) -> int, x: int) -> int {
        f(x)
}

fn add(x: int) -> int {
      return x + 5;
}

apply(add, 9)

fn adder(x: int) -> fn(int) -> int {
      fn g(y: int) -> int {
          x + y
      }

      return g;
}

let add5 : fn(int) -> int = adder(5);
add5(10)

No time to add polymorphic join type, i.e join t only has type unit, doesn't take the type of the spawn

[wxiaoyun]

We need this to make the race condition more obvious?

[wxiaoyun]

This is insane! LGTM