Ok I'm way too sleepy to think about this rn
SCUFFED AF struct dereferencing.

Rip out the `StructRef` typechecking, add a "type deconstructor" operator
(postfix `$` sounds cute), and make it work for real.

On the other hand this lame-as-shit module setup appears to work, which
is interesting.
BEHOLD MY POWER MUAHAHAAHAHHAHAHAHAAAAAA
omgomgomgomgomg
omg I can typecheck generics

let's gooooooooooo
Make sure generics on typedefs are declared
syntax bikeshedding wheeee
Okay I have managed to find a typechecker bug.

```
type Foo = {I32, @A}

fn thing(i: I32, x: @A): Foo =
    $Foo {i, x}
end

fn main(): I32 =
    let f2: Foo = thing(4, true)
    3
end
```

This typechecks and probably shouldn't, but if I change the signature to
`fn thing(i: I32, x: @B): Foo` then it doesn't.
Guess we need a generic type constructor syntax
Hmm ok basic structs work

Ok uh I guess we need to be able to stick generics in em now?
AST and parser for structs

The syntax is pretty lame but here we are
I guess we can make nominal types now
more helpful test naming
Refactor function checking.
Rrrrrrremove symtbl generic bindings

I feel like this is a mistake but I guess its subsumed by the
`named_types()` in `instantiate()`

Oh we're about to put something almost like it back for type
decls, but that's different.
aaaaaaaaaa lambdas appear to work
Tuples now seem to work.

I am concerned because this is going too well.
Minor cleanup.  Let's try again to add tuples.
mergeded

Backing out a bit to take a different approach to named types.
Next