Kill setMathQuillDot()'s hardcoded string keys #refactor #cleanup

This was dumb and smelled even when it was introduced:
https://github.com/mathquill/mathquill/pull/104#discussion-diff-1175704

Not only is it obviously simpler to just set MathQuill.MathField (etc)
than a variable key that's actually one of a few hardcoded strings, but
APIFnFor(APIClass) is such a more descriptive name and signature, like,
what did setMathQuillDot() set MathQuill dot to anyway? Creating the
corresponding public API function for an API class is what most of this
code is actually about.

Also rewrite relevant comment, and rewrite relevant README entry to
match phrasing of comment.
Add and test global MathQuill.options default opts
Add .options to cursor to be available to commands
supSubsRequireOperand inst of disableCharsWithoutOperand

Superscripts and subscripts are really the only (semantically) postfix
commands that is visually imprecise; if you accidentally type / twice,
for example, it's pretty obvious.

Also, now a per-field option (can be set globally on  MathQuill.option,
of course).
Add per-field charsThatBreakOutOfSupSub option

...to replace global MathQuill.addCharsThatBreakOutOfSupSub() (it can
still be set globally on MathQuill.option, of course).
Fix autocommands' auto-unitalicized commands check

The point of this check to is to prevent an infinite loop from setting
an autocommand like `sin`, which would try to create `\sin`, which is an
UnItalicized that, in createLeftOf, writes the 3 Letter's 's', 'i', and
'n', which if set as an autocommand would try to create `\sin` and hence
infinite loop.

Since this check was first added (#265), it's become possible to
override `UnItalicizedCmds` (#301), which would break the
`UnItalicizedCmds.hasOwnProperty()` check. Instead, now test directly
for whether the autocommand would create an UnItalicized.
Move .setHandlers() to EditableField::initRootAndEvents

Move root.setHandlers() call from special-cased in MathQuill.MathField
in src/commands/math.js to MathQuill.EditableField in src/publicapi.js,
so that it'll work for MathQuill.TextField's too, and also, not
coincidentally, so it's in the same file as the .setHandlers() method,
defined in RootBlockMixin.
Move Controller linking-up into Controller::init #refactor

Factor out the Controller/API object linking-up-to-each-other code from
AbstractMathQuill::initRoot and InnerMathField::init into
Controller::init.

And, InnerMathField::init now does setup first, then puts cursor at the
end after all the math rendered from LaTeX, just like MathField.

It sucks that the completely unrelated `leftRightIntoCmdGoes` option
processing code had to be tweaked, and only because we haven't had a
good architecture for it and opted[1] to override Controller::init,
which is brittle in exactly this case. Luckily that's gonna be fixed a
few commits later on this branch. Also, so glad for the test case[2] or
I would never have noticed.

[1]: https://github.com/mathquill/mathquill/commit/7d2214eb71efbee5b6453791297429668841d7a4#diff-2
[2]: https://github.com/mathquill/mathquill/commit/7d2214eb71efbee5b6453791297429668841d7a4#diff-a3de19b1ac6167152005fb40ac271d47R139
Fix duplicate default auto-unitalicized #cosmetic

https://github.com/mathquill/mathquill/commit/a4ae77cc5378ed9d25e5c111426a2b55227808e8#commitcomment-7273567
Fix overrideAutoUnitalicized emptying on error

Fix overrideAutoUnitalicized blowing away the whole UnItalicizedCmds
when given an error value; it should leave UnItalicizedCmds the way it
was before rather than emptying it.

Now, on an error, the exception is thrown before the UnItalicizedCmds or
MAX_UNITALICIZED_LEN variables are overwritten.
Reduce "unitalicize"/"un-italicize" inconsistency #cosmetic

We weren't being consistent with whether to camelCase it as UnItalicized
and autoUnItalicized or AutoUnitalicized, and whether to dasherize it as
unitalicize and auto-unitalicized or un-italicized. The main problem is
"auto-un-italicize" is weird and awkward, but "unitalicize" almost looks
cognate with "unital", which is a real math word.

From now on, no more "unitalicize", only "un-italicize" and only when
it's absolutely necessary to use the verb; where possible, use "operator
name" and "non-italicized". ("non-italicized" appears in the Wikipedia
article on "Italic type", whereas none of "un-italicized",
"unitalicized", nor "de-italicized" appear; and "non-italicized" has
many more Google search results than any of the others.)

In particulary, externally (in the README), I now call the option
"autoOperatorNames", and talk about "operator names that automatically
become non-italicized", avoiding the verb form completely. (Also clarify
"without typing a backslash first" instead of "outside a
`LatexCommandInput`".)

Instead of the UnItalicized command, it's now the OperatorName command,
especially fitting given the associated generic backslash command is
\operatorname.

Instead of the .mq-un-italicized CSS class, it's now .mq-operator-name.

Instead of "auto-unitalicized command" in comments (and the one error
message), say "operator name". In comments that have to use the verb,
just live with "auto-un-italicize", at least it's consistent with the
.autoUnItalicize() method.

Instead of MAX_UNITALICIZED_LEN, it's now MAX_AUTO_OP_NAME_LEN, and
instead of UnItalicizedCmds, it's AutoOpNames, which matches variable
name AutoCmds better.

To contrast with AutoOpNames, it's now BuiltInOpNames instead of
OperatorNames, and for consistency, it's TwoWordOpNames instead of
TwoWordOps.

Similarly, rename similar-sounding `trigOps` and `trigs` variables to
contrasting names `builtInTrigs` and `autoTrigs`, respectively. (Also,
simplify builtInTrigs, why weren't they all in one string? [1])

[1]: https://github.com/mathquill/mathquill/commit/a4ae77cc5378ed9d25e5c111426a2b55227808e8#commitcomment-7294720
MathQuill.config() instead of MathQuill.options

No more global MathQuill.options default options [47e3895][], which was:
- inflexible: special processing for leftRightIntoCmdGoes was done by
  overriding Controller::init, how ugly is that?
  Was specifically problematic just a few commits ago [6a043a9][].
  The special processing required for autoCommands and autoOperatorNames
  would only be worse.
- a needlessly different syntax from per-field options, in a way that's
  annoying if you set many options, because you'd have to do:

    MathQuill.options.spaceBehavesLikeTab = true;
    MathQuill.options.supSubsRequireOperand = true;
    MathQuill.options.leftRightIntoCmdGoes = 'up';

  Now instead it's

    MathQuill.config({
      spaceBehavesLikeTab: true,
      supSubsRequireOperand: true,
      leftRightIntoCmdGoes: 'up'
    });

Also add to AbstractMathQuill a .config({ ... }) method to dynamically
change the options from what was supplied to the constructor, again with
the same syntax. It's actually not coincidence that these 3 ways of
setting options (global defaults, per-field on creation, per-field
dynamically) all use the same options object format, they in fact share
the same code, so that's cool.

Mention the new .config() methods in the README (the options example now
stores the created math field in a variable so we can talk about
dynamically changing its options).

[47e3895]: 47e38957d14f878a9ddaa921e82ed4cf46ed2d4b
[6a043a9]: 6a043a93cb4e561d54c335857b182dadb9342147
Unit test page complains about uncaught errors

The next commit breaks MathQuill.addAutoCommands(), but that call is
directly in the 'auto-cmds' suite() of typing.test.js rather than in a
test(), so Mocha doesn't notice and in fact ends up not registering any
subsequent tests and may even show "100%" in the top-right corner, with
no indication anywhere on the page of an uncaught exception. Until now.
`autoCommands` option instead of addAutoCommands

Replace MathQuill.addAutoCommands() with `autoCommands` config option
(i.e. for use with either `MathQuill.config({ ... })` or in the options
object passed to the MathQuill.MathField() constructor).

By virtue of the config options architecture, it can now be overridden,
it can be a different set for different math fields, and it can be
changed dynamically on a per-field basis.
overrideAutoOperatorNames => autoOperatorNames option

Replace MathQuill.overrideAutoOperatorNames() with `autoOperatorNames`
config option.

The big external change is now there are no weird standalone "Global
Behavior Options", all options are config options and may be set
globally with `MathQuill.config({ ... })`, finishing resolving #286
(specifically the part about being able to remove auto-commands, set
them per-field, etc).

The big internal architectural change is that finalizeTree,
siblingCreated, and siblingDeleted now take in the options object as
their first argument, a change that has to happen in unfortunately many
places. Luckily, that change is completely straightforward in all but
one of those places.

The exception is MathElement::finalizeInsert, which appears to take in a
cursor as an argument, so I wanted to just use `cursor.options`, but it
turns out the `cursor` parameter is part of an opaque contract where
only Controller::writeLatex passes in a cursor (apparently) [0].
I'll add a comment about this weird contract in the next commit.

[0]: https://github.com/mathquill/mathquill/commit/ea7307eb4fac77c149a11ffdf9a831df85247693#commitcomment-7378712
Comment opaque contract on finalizeInsert 2nd arg

https://github.com/mathquill/mathquill/commit/ea7307eb4fac77c149a11ffdf9a831df85247693#commitcomment-7378712
Move `handlers` to the end of options example #docs #cosmetic

Now the order of the options in the example exactly matches the order in
which they're documented.
Add docs and error-checking for substituteTextarea
Comment statelessClipboard TODO

The current default behavior (new as of #269) is the one Desmos wants,
but the clipboard format being stateless was a sensible idea, I just
never properly implemented it, leave it as a TODO for now but at least
comment it.
Add visual test for public API options

They had unit tests, but no test case you could actually play with.