:: operator
Added classes and modules to the CS interpreter and parser

Classes can be defined with the class keyword. They may have an optional name and a superclass preceded by `<`. For example:

```
class Foo
	...

class Bar < Foo
	...

(class < Bar
	...
)
```

Classes can be instantiated with the `new` method:

```
Foo.new
Bar.new
(class < Bar
	...
).new
```

The class body is a normal sequence, evaluated in a scope containing the following variables:

- exports: the class funject itself
- instance: the funject for defining instance methods of the class
- super: the class's superclass

Instance methods can either match a list of one element (the instance itself) or two elements (the instance itself plus an argument). For example:

```
class Foo
	instance.one = {
		[@self]: one
	}
	instance.+ = {
		[@self, @x]: @x + 1
	}
	instance.plus-one = {
		[@self, [@value]]: @value + 1
	}
```

These examples could then be invoked on a Foo instance with:

```
fooInstance.one # => 1
fooInstance + 3 # => 4
fooInstance.plus-one[4] # => 5
```

They could also be invoked statically on a given instance with:

```
Foo.instance.one[fooInstance]
Foo.instance.+[fooInstance, 3]
Foo.instance.plus-one[fooInstance, [4]]
```

Because this is a common operation, Yak includes a `::` operator such that `Foo::bar` is simply an abbreviation for `Foo.instance.bar`. Thus, the above invocations could also be written as:

```
Foo::one[fooInstance]
Foo::+[fooInstance, 3]
Foo::plus-one[fooInstance, [4]]
```

This makes it easy to invoke superclass methods within an instance method definition:

```
class OverrideFoo < Foo
	instance.+ = {
		[@self, @x]: super::+[@self, @x] / 2
	}
```

Classes may also define the special instance method `initialize`, which is called to initialize a new instance of the class when it is created.

```
class Counter
	instance.initialize = {
		[@self]: @self.count = 0
	}
	instance.increment = {
		[@self]: @self.count = @self.count + 1
	}

c = Counter.new
c.count # => 0
c.increment # => 1
c.increment # => 2
c.count # => 2
```

Modules can be defined like classes with the `module` keyword:

```
module Foo
	...

module Bar < Foo
	...

(module < Bar
	...
)
```

Module bodies are evaluated in a scope with only two variables:

- exports: the module itself
- super: the module's parent

Modules are simply syntactic sugar for the inheritance operator; for example, the following module statement:

```
module Foo < Bar
	exports.bar = super.bar + 1
	exports.identity = {[@it]: @it}
```

is equivalent to the following sequence:

```
Foo = {} << Bar
Foo.bar = Bar.bar + 1
Foo.identity = {[@it]: @it}
```
Merge branch 'classes'

Conflicts:
	interpreter/interpreter.coffee