TextBlock::parser()'s returned Parser yields self

rather than creating a new TextBlock instance, creating its blocks and
adding text to it, and yielding that, just create my blocks and add text
to me and yield self.

A minor mistake we probably made because we were in the mindset of
\left's Parser, which has to create a new Bracket instance (or subclass
thereof).
TextBlock::onKey => InnerTextBlock::deleteOutOf

fix backspace and arrow keys in TextBlocks, helps with #121

Oh my god, deleteOutOf is so much prettier, simpler, and cleaner than
doing key checking logic in onKey! And it, y'know, works, which also
technically counts as improvement.

Discovering abstraction barriers and watching it simplify everything is
such a magical feeling.
get rid of Cursor::insertNew

it was just a thin wrapper for MathCommand::createLeftOf
refactor Cursor::write/insertCh()

First of all, the selection logic is separated from the character
parsing in insertCh() and moved into write(), which does it by calling
prepareWrite().

The ill-placed selection logic in the .mathquill('write', latex) public
API call is deleted now also just calls Cursor::prepareWrite().

So, prepareWrite() is like prepare{Move,Edit} except instead of calling
{clear,delete}Selection, it calls replaceSelection().

They both return the Selection Fragment, which is totally not clear from the
name of prepareWrite(), but it hopefully will get better refactored
later into this environments refactoring, for now it just refactors
duplicate code between Cursor::write and the .mathquill('write', latex)
public API call.
Cursor::insertCh now a wrapper for .parent.write()

math-specific character-writing logic moved to MathBlock::write()
RootMathCommand monkey-patches write instead of onText

it's cleaner this way, in particular the cursor gets passed to the
.write() call so it no longer needs to be gotten from the
RootMathCommand's constructor call.

(Unfortunately the cursor still needs to be passed into the
RootMathCommand constructor so it can be set as a property on the
RootMathBlock for RootMathBlock::on{Key,Text} to use.)
RootTextBlock overrides write rather than onText

it's cleaner this way, in particular the cursor gets passed to the
.write() call so it no longer needs to be gotten this.cursor (as set
by createRoot()).
LatexCommandInput hooks onText instead of write()

it now monkey-patches its child block, overriding MathBlock::write(),
rather than overriding onText on itself. Aside from the monkey-patching
(which will go away later in this environments refactoring as we get rid
of the double-layered tree), this is much cleaner because the cursor
implicitly takes care of cursor stuff for us, in fact it just naturally
fixes #123.
TextBlock::{write,onText} => InnerTextBlock::write

big diff, but not much happened:
- all the code in TextBlock::onText was moved to InnerTextBlock::write,
  which doesn't rely on this.cursor being set on the TextBlock
    + (which had caused all TextBlocks that were rendered from LaTeX
      rather than created with .createLeftOf() to error when typed in,
      so this fixes #121)
- the one-liner TextBlock::write is now directly inlined into
  InnerTextBlock::write
    + which .createLeftOf() calls instead of TextBlock::write. Note that
      now that means .createLeftOf() now does weird stuff on $, but $ is
      supposed to be treated specially anyway, will fix later.