The v3_life pass does not do enough to be worth being its own
pass. Essentially it does two things:

* Calculates life-time information starting from the annotations
that v3_kernel provides. That part can be moved into v3_codegen.

* Rewrites the Kernel Erlang records to similar plain tuples
(for example, #k_cons{hd=Hd,tl=Tl} is rewritten to {cons,Hd,Tl}).
That rewriting is not needed and can be eliminated.

The goal of this pass is to find values that are built from
patterns and generate aliases for those values to remove
pressure from the GC. For example, this code:

   example({ok, Val}) ->
       {ok, Val}.

shall become:

   example({ok, Val} = Tuple) ->
       Tuple.

Currently this pass aliases tuple and cons nodes made of literals,
variables and other cons. The tuple/cons may appear anywhere in the
pattern and it will be aliased if used later on.

Notice a tuple/cons made only of literals is not aliased as it may
be part of the literal pool.

As part of sys_core_fold, variables involved in bit syntax
matching would be annotated when it would be safe for a later
pass to do the delayed sub-binary creation optimization.

An implicit assumption regarding the annotation was that the
code must not be further optimized. That assumption was broken
in 05130e48555891, which introduced a fixpoint iteration
(applying the optimizations until there were no more changes).
That means that a variable could be annotated as safe for
reusing the match context in one iteration, but a later iteration
could rewrite the code in a way that would make the optimization
unsafe.

One way to fix this would be to clear all reuse_for_context
annotations before each iteration. But that would be wasteful.

Instead I chose to fix the problem by moving out the annotation
code to a separate pass (sys_core_bsm) that is run later after
all major optimizations of Core Erlang has been done.

Rewrite the instruction stream on tagged tuple tests.
Tagged tuples means a tuple of any arity with an atom as its first element.
Typically records, ok-tuples and error-tuples.

from:
    ...
    {test,is_tuple,Fail,[Src]}.
    {test,test_arity,Fail,[Src,Sz]}.
    ...
    {get_tuple_element,Src,0,Dst}.
    ...
    {test,is_eq_exact,Fail,[Dst,Atom]}.
    ...
to:
    ...
    {test,is_tagged_tuple,Fail,[Src,Sz,Atom]}.
    ...

The guard optimizations in v3_kernel has removed the need for
beam_bool.

The previous commits have made sys_pre_expand superfluous. Since
sys_pre_expand is undocumented and unsupported it can be removed in
a major release without prior deprecation.

Also remove code in erl_parse that handles abstract code that has
passed through sys_pre_expand.

We considered deprecating sys_pre_expand just in case, but decided
against it for the following reasons:

- Anyone brave and knowledgeable enough to use sys_pre_expand should
be able to cope with sys_pre_expand being removed.

- If we kept it, but didn't test it anywhere in OTP, it could
potentially stop working. So we would probably have to add some test
cases.