Improvement on the translation for pattern matching.

Both in terms of simplicity of the compiler code and in size
and simplicity of the emitted code.

It builds on generalizing the js.LabeledStat AST node, which was
valid only in statement position, as js.Labeled which is also
valid in expression position. The result of a Labeled expression
  a: { <body> }
is its body, unless evaluation of the body hits a
  return(a) <expr>
in which case it is the returned expression. Such a return is
represented as a js.Return(expr, Some(js.Ident("a"))). It is
considered a return rather than a break because they share more
semantics with return than break. This makes perfect sense if
you consider the labeled expression as a call to a function
that has been inlined.

With this new JS AST node, pattern maching translation does not
have to deal with 1) creating a temporary variable for the result,
and 2) distinguishing between Unit and non-Unit cases. Instead,
it can simply wrap the cases in a labeled expression, and jumps
to the matchEnd label ared translated as simple labeled returns.

JSDesugaring takes care of desugaring these into labeled
statements and labeled breaks. It can do a better job at
minimizing emitted code with this structure, because it can also
consider labeled returns as LHSes that can be pushed into
complex RHSes. But more importantly, because can push outer LHSes
into the labeled expression, often eliminating the need of the
labeled expression altogether when the LHS is a js.Return itself.
This is actually a very common case in Scala code, which happens
every time a match appears in result position of a function. So
we spend a few lines in the compiler optimizing that case to
save a lot of emitted code.
Do not print else branch when it is js.Skip().

This cleans up a bit more the emitted code, especially
code coming from pattern matching.