Simplify interpreter and implement core runtime

A number of definitions that were not specific to the interpreter have
been moved out of the interpreter prototype and into either the runtime
or tasks. Most importantly, the 'apply' method has been moved to the
runtime, which allows it to be used in the primitive definitions without
any reference to an interpreter. An interpreter no longer has stores
whether or not it is asynchronous, and method application is
asynchronous.

Synchronous methods are wrapped into a task that will immediately
resolve. Asynchronous methods may be executed immediately by calling a
special 'now' method on the task that is returned from the apply
function. Note that 'now' is not a force method, as the task is not
guaranteed to actually complete as a result of invoking it (and there is
no error if it does not), it simply bypasses the call to setImmediate
by running the function directly.

The test suite is halved by the change, as there is no longer any
synchronous behaviour to test. When synchronous methods are introduced,
they may be tested manually.

The primitive definitions of the runtime have also been fleshed out.
Currently they assume that methods are asynchronous (as there are no
synchronous methods yet) but it would be nice in the future to ensure
this assumption with proxies.
Standardise variable and type access

Variables and types were implemented as synchronous methods, which
exposes their definition when they should be indistinguishable from
methods. They now appear exactly as methods in both the object they are
defined in and the local scope, but the scope access for values that are
known to be variables shortcuts through the 'value' property.
Use asynchronous asString in interactive mode

The toString method on Grace objects will defer to the default asString
if the method is asynchronous. Now the interactive mode will always use
asString and simply wait for it to complete if the value is a Grace
object, otherwise it will defer to the object's toString.
Add varargs and tidy primitive definitions

Methods can now have variadic arguments, which allow setting a minimum
on the number of arguments that they take rather than an exact number.
The runtime has been updated to include simple lists and the list
pattern definition has been fixed.

Other small bugs exposed in the runtime have been patched, including the
fallback of the toString method on Grace objects. Specific boolean
constructors and inheriting match results have been added to the
primitives, but the external runtime API for their creation is
unchanged.
Add match method to blocks

Single parameter blocks are now patterns, with a match method that
defers to that parameter's pattern, allowing a test to see if an
application of that block will work for a certain argument. Blocks which
have no or many parameters raise an exception if you try to match
against them.
Add exception and packet primitives

The exception and exception packet primitives have been added as
constructors to the primitive definitions, and the internal definitions
have been updated to use them. The parser, interpreter and runtime
machinery still throw strings, but these are now reported as internal
errors. They should be updated to use the new exceptions in the future.

The packets do not yet build up a stack trace, and native errors are not
wrapped, both of which should also be patched. The InternalError
exception will catch native errors though.
Finish interpreter exceptions, simplify variables

The exceptions are now in their own module, and have been fleshed out to
cover all of the interpreter and runtime exceptions (but not those from
the lexer or parser, which will be updated in the future). All of these
exceptions are in every interpreter's scope so they can be requested by
name. The test harness and run script have been updated to differentiate
between Grace exceptions and internal errors. Catching packets and stack
traces are next.

As part of this change, the way variables (and type definitions) are
defined has been updated to use methods from the runtime. Hoisting
creates methods that throw an Undefined Value exception until the value
is set (or Uninstantiated Type for types). A test for the Invalid
Inherits exception has also been added.
Add try() catch() and handle internal errors

Exception packets can now be caught with the try() catch() method.
Methods defined by the runtime will catch regular errors and wrap them
up in an Internal Error exception packet before throwing them again.

A bug in the interactive mode that printed out full errors instead of
their messages when handling regular errors has also been resolved.
Clarify return and super behaviour

The error handling behaviour of method exits was built in preparation
for building stack traces with the exceptions, but this will be handled
by the runtime rather than the interpreter so it has been removed.

The lookup behaviour of return and super was almost redundant in the
presence of the search method, so search now detects self and does not
proceed further when searching for either case. Rather than raising an
error when the return exit function is not found, the exit function
replaces itself with a function that raises the error when it is called.

Some minor whitespace issues in the exceptions module have also been
fixed.
Add stack traces to exception packets

Exception packets now trace the methods and objects they were in and
dump this information if they are not caught. The trace includes the
name of methods, the object the method was called on, and the module the
method was defined in. This information is not yet exposed as through
methods on the packets themselves.
Add location information to exception stack traces

The lexer now captures line and column information for each token, and
this information is piped through the parser and into the interpreter.
Every packet that is raised by the interpreter has this information from
each node it encounters attached to its stack trace as it unwinds the
stack. Internal methods are just reported without location information.

Exceptions raised by the parser and interpreter are now all
sub-exceptions of the Grace exception Error. The parser does not yet use
location information in its own errors.
Add location information to parse errors

Parse errors now report the module, line, and column information when
they are printed out, along with a full stack trace if the error was the
result of a valid import. The tests for parse failure have been split
out into their own suite.

One test that was failing to parse but should have parsed and then
raised an Error has been fixed, and the test harness will now
distinguish between the two.
Add outer, boolean keywords, common indentation

The use of true and false are now only allowed as direct requests, and
requesting outer will now return the self value above the current one in
scope. Chains of outer resolve to a single AST node that resolve to the
appropriate self value in scope.

The indentation of the tests has been standardised to two spaces.
Use a token hierarchy instead of string types

The lexer and unicode modules have been moved under the parser, and the
lexer tokens are now distinguished by constructor rather than by a
string type. They now have a much more consistent string representation
and location information, and the parser uses unlocated tokens to report
missing tokens. A number of untested parse failures have been added.
Unify variable definitions and test their patterns

The hoisted and unhoisted variable definitions are now unified into the
same evaluation. Both the initial value and assigned values are tested
against the definition's pattern.
Use value equality, fix number operators

String and number equality now tests against the primitive value instead
of object identity. The number operators used an invalid pattern, which
has now been fixed.
Remove : as an operator, make return types strict

The : symbol is now banned as an operator. Names in return types were
consuming the body of the method as a block, so they are now also
strictly parsed.