s/expandSelection/extendSelection/g

retract vs extend, not expand
root uses Cursor::{{start,end}Selection,select}

and doesn't touch the anticursor, which is now stored on the cursor,
created/deleted by start/endSelection, and instead of checking whether
the anticursor is the same as the cursor then calling selectFrom,
selectFrom has been replaced by select, which accesses and checks the
anticursor on the cursor.
add and use Point.copy(pt)

note that Point::clone() would make cursor.clone() return a Point when
it looks like it should return a Cursor
clarify comment in Cursor::seek #comment #cosmetic
unify focusing the least-common-ancestor block
comment editability methods section of TextBlock #comment #cosmetic
fix TextPiece::deleteTowards for >2 TextPieces
TextPiece::selectTowards tail-calls deleteTowards
{create,expand,retract,clear}Selection => selectTowards

but with a different contract from before: after selectTowards or
selectOutOf is called, cursor and anticursor should be in the right
place and ready for Cursor::select().

In other words, refactor {create,expand,retract,clear}Selection and
selectOutOf logic to use more general Cursor::select instead.

Cursor::select also changed to return true or false depending on whether
anything was selected.
Cursor::withDirInsertAt only blurs if parent changes

Fixes keyboard selection throwing exceptions.

This is so TextPiece::selectTowards (which calls Cursor::insertAdjacent
which calls Cursor::withDirInsertAt) won't cause
TextBlock::consolidateChildren to be called (by TextBlock::blur), which
messes up the tree positions that the cursor and anticursor are at when
doing selection with the keyboard.

Also, don't bother waiting til after moving the cursor to call
this.parent.blur(), that was some bullshit I pulled to hack together the
original TextBlock:
https://github.com/mathquill/mathquill/commit/e15a85fffbb3c1f0cdbdd1bf1c3fe4ee05581e7c#L2L44

Note that this only narrowly fixes keyboard selection throwing
exceptions, focus/blur are still fucked; if you blur by clicking on the
address bar, for example, then tab back, the cursor's gone and the
tree's messed up.
fix everting selection in TextBlocks

i.e., do Shift-Left, then Shift-Right twice
fix #169 typing $ or \text throws

whoops apparently I was an idiot in #131 "TextPiece: override jQadd
instead of finalizeTree"
Node::jQadd returns the jQ instead of undefined

useful for the TextPiece::jQize/jQadd cleanup (next commit), and it's
what you'd expect
tiny refactor of Text{Block,Piece}::jQ{add,ize}

also remove comment, which wasn't adding anything. All we need to make
those methods understandable is documented contracts for jQize/jQadd
mouse-selecting TextBlocks mostly works!

implement TextBlock::seek to consolidate all the children and do
cursor.seekHoriz() every time, recording the anticursor's position on
the initial mousedown, otherwise re-creating the anticursor as a Point
(which may require splitting up a TextPiece).
make Cursor::offset() a public method

because the various overrides of Node::seek(pageX, cursor) need access
to it
recursively delegate ::seek to each node

* removes Cursor::seekHoriz
* ::seek on MathBlock and MathCommand now measure each child rather
  than moving the cursor (supersedes and closes #154)
* Text::seek inlined ::seekHoriz
clean up MathCmd::seek #cosmetic

factor out all the ugly, unclear .jQ.offset().left / .jQ.outerWidth()
business into getBounds()

also move dealing with the rightmost block into eachChild iteration

primarily written by @jayferd
TextBlock::seek slightly cleverer: guess position

TextBlock::seek now slightly more clever: it starts by guessing the
approximate position the cursor should end up based on the offset of the
character within the TextBlock and the average character width. In
most typefaces the width of each character varies widely, of course
('i' is usually much thinner than 'm'), but that doesn't matter if the
characters are distributed randomly in the string (as opposed to
clustered), and in typical text that would actually be typed, that's
close enough to true that this is still a good guess.

Because the cursor now might start on either side of the mousedown
(`pageX`), the loop now has to be able to move in either direction.

Also, for convenience, consolidateChildren() now returns the newly
consolidated child.
consolidateChildren now just calls Text::normalize

so the browser won't reflow

contract for consolidateChildren now requires cursor's jQ to not be in
the TextBlock, so seek now detaches the cursor, and reattaches it before
calling Cursor::offset()