Taskify portions of the parser, making it async

The larger parts of the parser are now asynchronous, using the Task API.
This means that the parser will also be non-blocking. It should also
ease a transition to a token stream rather than manually splitting
tokens synchronously. The token operations remain synchronous for now.

The callback method on tasks can now handle undefined and null values,
and the prelude will report its module name if an error occurs. The two
external interpret methods now also take an optional module path, which
will be used for reporting in case of errors.
Add a stop method to halt a chain of tasks

It is now possible to stop an executing task and its dependencies by
calling the stop method. This method has no effect on completed tasks,
but will cause currently pending tasks to be rejected with an
InterruptError. Use of stop propagates down a chain of tasks, stopping
all dependent tasks. There are no guarantees as to how quickly all tasks
will be stopped, and the method will not stop concurrent tasks that were
spawned by, but are not in, the dependency chain.

The external interpreter methods now each return a function that can be
used to stop the underlying task.
Modify outer semantics to search all of scope

The outer semantics have been changed to work like super, where outer
may only appear as the receiver of another request. Outers can no longer
be chained, and ambiguities must be resolved by naming outer objects.
Tidy up inheritance and super semantics

The use of self inside an inherits request is now banned, with the same
Incomplete Object error that occurs when referencing it in annotations,
as the 'object' property on the scope is maintained when the first node
of an object body is an inherits clause. The processing of the clause
tidies up the property instead. A few other superfluous properties have
also been removed.

The rules for processing super requests are now more liberal, and they
may now appear outside of the method they are requesting. In all cases
use of super will resolve to the first method defined above the current
inheritance level, or an error if no such method can be found. This is
achieved by storing the existing definitions on the object at the moment
the inherits clause is encountered. A number of tests have been
introduced or changed to test this comprehensively.