Improve positions of some class definitions.
WiP for the the new IR.

wip

Add StoreModule as IR node.

Add constructor and module exports as IR nodes.

Get rid of the last NoType's.

Complete review of the typings of IR trees.

Now the emitted trees should be correctly typed.

Add array length and get/set as IR nodes.

Split away the ScalaJSClassEmitter off JSDesugaring.

The idea being that, eventually, the DCE will be able to call
the parts of ScalaJSClassEmitter which are reachable directly,
instead of emitting the entire JS code then parse it back.

Remove as many js.Cast as possible.

Now there are only two kinds of js.Cast that we use:
* js.Cast(expr, DynType) -> that's fine, anything can become a dyn.
* 2 down-casts from DynType to more precise types, where we really
  know that the expr will conform to the new type, even though the
  "type system" of the IR cannot prove it.

Reduce the scope of TreeDSL; eliminate it from the compiler.

TreeDSL is now package-private to scalajs.ir. It has also
lost its IF method, which was replaced by the If constructor
in the few places it was used.
Make line and column numbers in ir.Position zero-based.

Source maps use the zero-based convention for both the line
and column number, so we follow that convention.
Add serializer and deserializer of the IR.

To test them, GenJSCode currently does the stupid job of
serializing its IR and deserializing it before desugaring and
actual code emission.
Refactor hierarchy of virtual files to VirtualTextFiles.

The current virtual files are implicitly text files, but
eventually we will need to also represent virtual binary
files. This commit refactors the hierarchy to separate
VirtualTextFile (text) from VirtualFile (agnostic). This
refactoring will allow the later introduction of binary
files as VirtualBinaryFiles.
IR emitters accept Writers instead of PrintWriters.
Add the content of .sjsinfo files to the ClassDefs in the IR.

Eventually they should disappear, when the packager and
optimizer are working directly on the IR. But in the meantime,
this makes IR files self-contained: they aggregate everything
that is currently spread in three files: .js, .js.map and .sjsinfo.
Emit serialized IR files instead of .js + .js.map + .sjsinfo.

The ClasspathBuilder automatically expand .sjsir files into their
desugared VirtualScalaJSClassfile version for now. It is left for
a future commit to get rid of VirtualScalaJSClassfile entirely and
have the packager and optimizer to work directly on the IR file.
Remove VirtualScalaJSClassfile and use VirtualScalaJSIRFile instead.

Now the various tasks working with a ScalaJSClasspath extract the
information they need from the IR directly, and work with that.
Store the info first in IR files so they can be read faster.

The Rhino environment and the fast optimizer need only the info
(and not the tree) for most of the IR files. It was wasteful to
have them deserialize the whole tree to read only the info.

Now an IR file contains 2 successively serialized trees: first
the info, then the class definition.
Remove an indirection in emitting files in the packager.
Fix relativized URIs in source maps (again).

For the options relativize+relativize given to the compiler,
they should be applied before even creating the IR nodes, since
they will be serialized as is without going through the
SourceMapWriter, which previously did this job.

Then, the final relativization w.r.t. the packaged output should
use our Utils.relativize, not the one from URI, so that it can
create relative paths with '..'.