Make tasks completely asynchronous by default

Allowing task continuations to run synchronously produced a memory leak
that blew the stack out easily in recursive method definitions. Now
calls to 'then' on a task follow the Promises specification by dropping
the call stack before continuing. However, this behaviour can be
overridden by the 'now' function, present on every task, which forces
each subsequent task to run immediately as well. Trying to force a task
in this way fails if the task has truly asynchronous behaviour.

A number of definitions in the runtime have been updated to adjust to
this new interface. Method application still uses setImmediate, but
rather than creating a custom 'now' as it did before, it binds into the
new 'now' interface by setting the memoised function to be run on force.
Ensure method does not continue after return

The return statement was not actually halting the evaluation of a
method, and the actual behaviour was forking onto two paths: one that
continued from where the method was requested, and one that was still
inside the method. The existing test for this case is unable to test
this property correctly because only side-effects are visible from the
second path, and the harness does not take side-effects into account.
Recognise Unicode line separator character

The Unicode line separator character is a valid new line character, and
is now recognised by the lexer as such.
Remove mutation of node when generating inherits

The code that generated the inherits method in the interpreter was
mutating the actual method node by popping off the last statement from
the body. Now the body is cloned before this happens.
Update operator detection when making method name

The function that combined the parts of a method was using the parser to
check if a method part was an operator. Now it just checks the
'isOperator' property.
Use strict mode when parsing var type

If the type of a var was just an identifier, the parser attempted to
parse the assignment operator as part of the type. Types on vars are now
parsed in strict mode, which means they cannot contain assignments.