Feature Change: backspace/delFwd select empty cmds

the previous behavior was, when and only when backspacing/deleting
nonempty commands, like a nonempty fraction or a nonempty sqrt, to
select the cmd, otherwise directly remove it. The new behavior is to
only directly remove symbols, all commands that may have blocks will be
selected, including empty ones. This is more internally consistent.

(Prep for deletion being an inherited method from MathCommand that
Symbol will override)
rm Selection::{extend,retract}{Left,Right}

they were only ever called by select{Left,Right}, which have been
refactored into skeleton calls to selectDir, which calls
{extend,retract}Dir
MathCommand::moveTowards, MathBlock::moveOutOf

Cursor::moveDirWithin's logic for moving the cursor in the
double-layered math tree is now delegated to methods of MathCommand and
MathBlock

This starts to lay the groundwork for editing stuff besides the
double-layered math syntax tree, like text, or a math semantic tree
MathCommand::selectTowards, MathBlock::selectOutOf

like the previous commit, but selecting instead of moving the cursor

inline Cursor::hopDir, Selection::{extend,retract}Dir

The hopping methods were only ever used by selectDir/Left/Right because
we branched in what is now clearly the wrong order; if we had, from the
beginning, branched equivalently to what we're now using method
overriding for, the hopping code would never have been duplicated.

The Selection extend/retract methods were also only ever used by
selectDir/Left/Right, and while we thought of them as being about the
selection at the time, with the new idea we're trying to push for of a
dumb selection and since they had logic specific to the double-layered
math syntax tree, we now just inline them.
MathCommand::deleteTowards, MathBlock::deleteOutOf

just like the previous two commits, but backspacing/deleting forwards
instead of selecting or moving the cursor

Cursor::unwrapGramp is heavily double-layered-math-syntax-tree-oriented,
but I left it for MathBlock::deleteOutOf to call because I'm lazy,
and that behavior is fucked anyway
RootMathBlock::onKey now calls Cursor::escapeDir

which delegates to this.parent.moveOutOf

per the Occasionally Useful Suggestion of Demeter, it's really not the
root block's business to be looking at the cursor's parent and next and
telling the cursor where to go. In fact, it duplicated code from
Cursor::moveDirWithin that relied on the double-layered-ness of the
tree.

To sum up, in one semantic change this improves the code in 3 ways:
1. refactors duplicate code between RootMathBlock::onKey and
   Cursor::moveWithinDir
2. moves cursor logic into the cursor from the root editable
3. moves tree logic into the tree node from the cursor/root editable
all Nodes now have unique id's

rather than just MathElements

Also, Node.byId hashes all Nodes by their id, and Node::toString now
uses the format '{{ MathQuill Node #123 }}' rather than '[Node 123]',
which never made sense anyway since the string to match Object.toString
would be '[object Node]', this way at least it provides a little more
context if the string accidentally gets displayed somewhere.
Cursor::selectFrom just uses Fragment.between

Cursor::selectFrom(anticursor) now calls the thoroughly unit-tested
and commented Fragment.between(this, anticursor) to do the complicated,
bug-prone tree traversal to figure out which two Nodes are selected, and
in what order.

Note that Fragment.between goes through all ancestors rather than just
ancestor commands, which means the lowest common ancestor found may be a
MathCommand rather than a MathBlock and the two Nodes to be selected may
be MathBlocks rather than MathCommands.
Math{Command,Block}::selectChildren

Cursor::selectFrom(anticursor) now delegates to .selectChildren() on the
lowest common ancestor of the cursor and the anticursor
fix move{Up,Down} comment #cosmetic #herpderp

whoops never editted it to describe seeking
Cursor::move{Up,Down} checks .{up,down}{Into,OutOf}

rather than assuming a double-layered tree and treating .up and .down
on commands differently from on blocks (check .up or .down on adjacent
commands and append or prepend to it, but bubble through ancestor blocks
and seek the closest horizontal position within them), treat
.{up,down}Into differently from .{up,down}OutOf:
the former is for up/down when the cursor is next to them to move the
cursor up or down into them,
the latter is for up/down when the cursor is in some block (or the
descendant of some block) that the cursor should move up or down out of
Cursor::move{Up,Down} will seek in any Node

rather than assuming a double-layered math tree, bubbling only through
ancestor blocks and requiring that .{up,down}OutOf must be a MathBlock,
bubble through all ancestor nodes and allow .{up,down}OutOf to be any
Node, requiring only that the cursor can seek in it, like a good duck
typist should

For right now, that means it has to be a MathBlock, which all uses of
.{up,down}OutOf are.
fix typos in moveUpDown comment #cosmetic
fix up/down in \editable inside fraction

https://github.com/laughinghan/mathquill/commit/b03a8e7f8a4ad45dca13ff6a13c99a58fb553230#commitcomment-1746333
factor Cursor::jumpUpDown out of moveUpDown

comment separately
fix selecting multiple cmds X_X #ImAnIdiot #herpderp #typo
MathCommand::seek, Symbol::seek, MathBlock::seek

Cursor::seek now calls them and uses polymorphism rather than logic that
branches based on whether it's a Symbol or command or block

Should be functionally unchanged
in Cursor::seek, clear selection after target logic

functionality fix: fix occasional, when dragging to select, selecting
too much, which would happen because the target would be the selection
span which would be cleared before checking it's parents for a MathQuill
id, at which point it's parent would be null, and then the seeking would
start from the end of the root and would stop prematurely and the
selection would be too big.
use variable instead of this #cosmetic
move {MathElement => Node}::{bubble,postOrder}

they're actions on any kind of tree of Nodes

the text environment will need them