Add internal toNumber and toString helper methods

There were a lot of cases in the primitive method definitions that cast
a value to a built-in type and then converted it into a primitive. This
common case has been joined together in two helper methods for numbers
and strings.
Add a simple mutable list class and type

The list factory inherits from the sequence factory, so the sequence
factory has been adjusted to call factory methods on self rather than on
an outer reference. The lists themselves inherit from sequences, which
now have confidential methods 'internalPush' and 'internalSplice'. These
methods provide access to the underlying primitive array, without
performing primitive unwrapping when adding to the array.

The sequence methods have been adjusted to just pull the internal array
out of its local object state. Slice methods have also been added.
Remove single-part methods taking non-part arrays

Previously, passing the arguments of a single-part, non-generic method
call directly to the method in JavaScript was allowed as a special case
to permit a simple FFI system. Now this is the default, and passing a
JavaScript array that does not have a 'generics' property (which is how
part arguments are designated) to a single-part method will use the
array as a single argument, rather than its contents. Now passing normal
JavaScript arrays as parts is a special case for multi-part methods.

This commit also resolves an error in the Assertion Failure exception
that passed an array instead of a string to the string join method.
Remove the asPrimitiveString method on non-strings

The asPrimitiveString method was implemented on booleans and numbers as
a convenience. This confused the print() method, as it was identifying
these objects as strings, and not requesting the asString method. This
interfered with inheritance, where the asString method may be overridden
and return a different string representation than the one provided by
asPrimitiveString. Now only strings have the asPrimitiveString method.
Ensure a task stop cannot overflow the call stack

The stop method on tasks recursively descended through the tasks until
it found the one that was running. Large chains of dependent tasks could
cause this recursion to overflow the stack, producing an error instead
of stopping the task. Now the recursion uses the asap function to clear
out the stack at each step.
Replace custom Unicode data with npm module

The existing unicode module was large and unwieldy, as well as somewhat
inefficient. Now the project dev-dependencies includes Unicode 7 data,
which provides regular expressions for matching character classes. This
is used at build-time to generate a unicode module. This unicode module
no longer exports name information, and the lexer just reports the
actual character in case of an unrecognised character. The 'escape'
function has been moved to the util module.

The asap dependency bounds have been extended and brfs has been moved to
a dev-dependency.
Avoid name clash with existing module definition

Defining a method with the name 'module' clashes with the local
identifier for the surrounding module. This can be avoided by assigning
the function directly to the property on exports.
Use ESLint with custom rules instead of JSLint

ESLint is capable of checking more rules, and enforcing more stylistic
consistency. An ESLint configuration file is now included, which turns
on most optional rules, and the rest of the project has been modified to
conform to these rules. The major change is that array literals now
require padding. The consistent-this and and spaced-line-comment rules
require a minor patch to accept the existing style.
Reimplement while loops to reduce memory leaks

The existing implementation of the while() do() method formed a long
chain of every task created in the loop, retaining every task until the
loop finished. This was unnecessary, as each iteration does not need to
wait for the next to conclude the task. Now the loop creates a manual
task, which is resolved (or rejected) by the completing iteration. Each
individual iteration spawns the next, but it does not wait for it to
complete, and its tasks are not retained and they may be collected. The
outer task binds into the standard waiting mechanism for the current
iteration, and if stopped will stop its body as well.
Remove extra newlines at the end of files

The improved linting ensured that the JavaScript sources had exactly one
newline at the end of files, but this did not apply to everything in the
repository. This change covers the remaining files.
Bump the version number for initial release

Incidentally, the existing version number should have been 0.1.0-pre.
Add empty npmignore, bump version number

Without an empty npmignore, publishing ignored the required unicode
module, which made the previous release invalid. As such, this commit
marks a new release which should work on install.