When an error points to an external file, its source code is now read
and errors highlighted in it.

Error highlighting for code from the last load cell now also works when
an error pointing to it is thrown in a later cell (although this
doesn't happen often). The initial/default machine is also recognized
(although there should never be errors pointing to its code).

At the moment error highlighting is only supported for the
machine/formula in the current cell.

This significantly improves the performance of loading new machines.

If the cursor is after the command name, but before the start of the
argument string, it makes more sense from a user perspective to treat
it as if it was at the start of the argument string. This way if there
are multiple spaces between the command name and argument, the user can
still use code completion inside this whitespace and get completions
for the first parameter of the command.

This makes it possible to inspect B variables when the cursor is right
before the first character of the identifier.

There is now a single preprocessInput method that is responsible for
adding a command prefix to any input that doesn't already have one.
This simplifies the implementations of (eval|inspect|complete)Internal
somewhat, because they can now assume that the input (after
preprocessing) always starts with a command name.

This code was effectively never called - in Jupyter Notebook, pressing
Tab on a whitespace-only line will add an indent level rather than
triggering code completion.

The PositionedString offsets here now use the same origin as the "at"
index received from Jupyter. This way the "at" index and the
replacements no longer need to be offset manually after the command
name is removed from the string.

The PositionedString offsets here now use the same origin as the "at"
index received from Jupyter. This way the "at" index no longer needs to
be offset manually after the command name is removed from the string.

This position information isn't used for anything yet.

All code now uses the (bExpression|preference)(Inspector|Completer)
methods instead.

Argument splitting now happens before these methods are called, so they
only receive a single preference string, not all of them. Also renamed
the methods to indicate this.

Most of the inspection/completion code is no longer part of
CommandUtils.

This new implementation replaces the old separate implementation in
CommandUtils.completeArgs. This change is analogous to the previous
change that re-implemented command inspection.

CommandUtils.splitArgs now takes an extra (optional) parameter to ask
it to not split the entire argument string, but only up to the argument
at the given offset in the string. The returned SplitResult contains
information about which parameter the argument splitting stopped at.

This is used in the new implementation of the inspection feature: when
the kernel is asked to inspect at a certain position, the arguments are
split up to that position, and the argument at that position is
inspected. (The arguments are only split and not fully parsed, because
inspection should be possible even if the command arguments are still
incomplete or otherwise invalid.)

This new implementation replaces the old separate implementation in
CommandUtils.splitArgs.

This is useful in case the URL shortening service disappears or breaks.