It had been factored out in `SJSGen` because of one condition that
happens to be repeated. However, it is clearer that it does the
right thing at each of its call sites. Given the amount of
information that needed to be passed to this helper, inlining it
twice actually removes additional checks. Ultimately, it seems
simpler this way.

We introduce a new kind of node in JS ASTs: `DelayedIdent`. A
delayed ident is like an `Ident`, but its `name` is provided by a
resolver, to be determined later. This allows us to build a JS
AST with `DelayedIdent`s whose final names will only be known
later.

Since pretty-printing requires to resolve the name, it might throw
and is not so well suited to `show` for debugging purposes anymore.
We therefore introduce `JSTreeShowPrinter`, which avoids resolving
the names. Instead, it uses the `debugString` method of the
resolver, which can be constructed to display meaningful debugging
information.

`DelayedIdent` is not yet actually used in this commit, but will
be in a subsequent commit for minifying property names.

The only remaining public method is now `printStat(tree: Tree)`.

Previously, `SJSGen` generated `Ident`s for field members, but
only names for method members. Generating the `Ident`s for methods
was left in `ClassEmitter` and `Function`. Now, we concentrate that
responsibility in `SJSGen` only.

In addition, we make a clear distinction between idents generated
for *definitions*, which receive an `OriginalName`, and those used
for *use sites*, which never receive one.

When emitting ES modules, we cannot use Closure because it does not
support ES modules the way we need it to. This results in files
that are much larger than with other module kinds.

Off-the-shelf JavaScript bundlers/minifier can compensate for that
to a large extent for local and file-local variables, but they do
not have enough semantic information to do it on property names.

We therefore add our own property name compressor. When enabled,
the emitter computes the frequency of every field and method name
in the entire program. It then uses those frequencies to allocate
short names to them, with the shortest ones allocated to the most
used properties.

In order to compute the frequencies, we count how many times
`genMethodName` is called for any particular `MethodName` (same
for other kinds of names) during JS AST generation. That means
that while we generate the JS AST, we do not know the final
frequencies, and therefore the eventually allocated names. We
use `DelayedIdent`s to defer the actual resolution until after
the frequencies are computed.

Obviously, this breaks any sort of incremental behavior. Since we
do not cache the frequency counts per calling method, we have to
force re-generation of the whole AST at each run to re-count.
Therefore, we invalidate all the emitter caches on every run when
the new minifier is enabled. This should not be a problem as it
is only intended to be used for fullLink.

An alternative would be to store the counts along with global
refs in `WithGlobals`, but the overhead would then leak pretty
strongly on incremental runs that do not minify.

This strategy also prevents fusing AST generation and
pretty-printing. When minifying, we demand that the
`postTransformer` be `PostTransformer.Identity`. This adds a bit
of handling to `BasicLinkerBackend` to deal with the two possible
kinds of trees received from the emitter, but nothing too invasive.

We automatically enable the new minifier under fullLink when
GCC is disabled. This can be overridden with a `scalaJSLinkerConfig`
setting.