Includes full support for ARM BBC BASIC. Some features of BBC BASIC for Windows
and BBC BASIC for SDL2.0 are not included.

…::Prompt

…mixin

…ne first

…iority than built-in function ERR

…ommand introducer

This is done by introducing an extra state where CLI commands are not valid,
and classifying the control flow keywords according to whether they
transition in or out of this state. Not 100% safe yet, since detecting any
expression in :root state should mean that * can only be an operator.

By using a negative lookahead for when DIM and POINT are statements, rather
that a positive lookahead when DIM() and POINT() are used as built-in
functions, we can merge state :builtin_function into :expression. As a bonus,
since built-in functions are now tested at lower priority than control flow
statements, `ERROR` no longer needs its own rule.

This is achieved to inserting `goto :no_further_imperatives` every time we
identify a component of an expression, or reach a state where we expect an
expression next. Because these will not be balanced by the number of times we
return to :root, we can no longer use a state stack. This means that instead
of being able to do `mixin :expression` from state `:assembly2`, we need to
write out all the same rules again, but without the `goto`s.

Some of those keywords previously listed are not valid as an imperative
statement.

I don't think it realle helps to distinguish control flow statements from
other statements, especially since they are tokenised the same. Some keywords
(like `TINT`) have ended up in control3 even though they have nothing to do
with conrol flow, and others (like `OF`) can appear within either sort of
statement (`COLOUR OF x` and `CASE x OF`).

* `PROC` is permitted in an `ON` statement
* An imperative keyword is permitted immediately after `DEFPROCthing` without a
  separating colon

Added a few more examples to the visual spec

It isn't really  a built-in function (since it needs a function name to qualify
it, which is lexed as a variable), but it can appear within an expression.

Using a pair of states just wan't working - there are just too many exceptions
to the rules to handle cleanly. So instead, here we take the approach of only
permitting `*` to be lexed as a command introducer if it is at the start of a
line, or follows `:` or one of a restrictive set of other keywords.

Unfortunately, it appears that the lookbehind regexp syntax `(?<=)` doesn't
work here, so we have to lex the string including the lead up to the `*` as a
multi-token rule. This is fine in all cases except when the first line of the
file is a `*` command, but hopefully this will be rare enough that nobody
cares.