Experimental support for linear types

[EliasC]

This commit adds the possibility to mark a class (passive or active) as
linear. This means that all references to an object of that type must
be treated linearly, i.e. cannot be copied. Reference transfer is done
using the consume keyword. Here is an example program that shows most
of the current functionality:

linear passive class Foo
  f : Foo
  def foo() : void
    print "Foo"

class Main
  def main() : void
    let x = new Foo
        y = new Foo
        arr = [consume x, consume y]
    in{
        x = consume arr[0];
        x.f = consume arr[1];
        y = consume x.f;
        y.foo(); -- No consume needed for method calls
    }

The checking that linearity is preserved is done using an additional
pass, implemented in the file src/typechecker/Capturechecker.hs. This
keeps the changes made to Typechecker.hs to a minimum, which is nice.
Basically, the capturechecker figures out where references are captured
and when a linear reference is safe to capture.

The linear references should be interoperable with all the features
currently in Encore, but testing is very welcome! I will keep this in a
feature branch (and try to keep it rebased on master) until the
exclusive capabilities find their way into the type system.

It should be noted that consumes are currently not atomic (the value is
read and nullified sequentially), but this shouldn't matter in a
race-free program. Linear streams are possible but not very useful,
since both get and getNext require you to consume the stream. For
any useful patterns we would need a way to get and move the stream
forward in one go (maybe consume s should be the way to do this?).

[EliasC]

I'm going to merge this myself since it's not going into master. A proper review can be done when we're merging it into the master branch.