Fix dominatorForest calculation for SSA2

Copy 60efb65 "Fix dominatorForest calculation." to the SSA2
implementation of the dominatorForest.

It's also become apparent that the fakeRoot and fakeBlock just float
around after the dominator forest has been built, since they are a part
of the graph.  Another pass will have to be made to actually remove
these from the graph, in a later commit.
Convenience functions for SSA2 FunctionEntry

Copy the functions from b78d153 "Convenience functions." into SSA2;
uncomment the 'args' function.
SSA2: Make 'main' a FuncEntry, not a Func

During my initial pass converting the SSA2 IL to multi-entry functions,
I did not change the type of Program.main to a FuncEntry.  'main' needs
to be a FuncEntry, because 'FuncEntry's are now the the labels used for
intra-function transfers.
Copy SSA2 passes needed to convert ssa2.fun to multi-entry

These are all of the passes that are needed to build the Ssa2 functor.
All of them will have to be converted to multi-entry functions before a
MeSsa2 functor can be exported.

These files are here temporarily and will be removed once the
multi-entry pipeline is set-up and stable.
Convert SSA2 Analyze to the multi-entry SSA2 IL

The conversion was idential to:
70cf8a7 Convert SSA Analyze to the multi-entry SSA IL
SSA2: Convenience functions for finding 'main'
Convert the SSA2 type-checker to the multi-entry SSA2 IL

Changes were almost exactly like:
251bd86 Convert SSA type checker to multi-entry SSA (partially)

This is change still leaves out rules that are specific to multi-entry
functions (such as making sure that every entry is a root in the
dominator forest).

Type checking profiling statements is still incomplete.
Convert the SSA2 PrePasses functor to the multi-entry IL

This was straightforward since 'args' and 'start' were just being used
to re-build functions --- only the blocks were being modified.
Convert the SSA2 Shrink functor to the multi-entry SSA2 IL

Like 4910911 (which was for SSA1), the approach here was to convert
single uses of 'args' or 'start' by generalizing them over all entry
points, using Vector.foreach or Vector.map.
Convert SSA2 Simplify to the multi-entry SSA2 IL (partially)

As in ddd66b11 (which was for SSA Simplify), the "conversion" is simply
disabling optional SSA2 passes.  In this case, there were no mandatory
passes so all of them have been disabled.

The disabled passes will be added back in once the pipeline for
multi-entry functions is complete and the regression test suite can run.
Export a multi-entry SSA2 functor

A new functor, MeSsa2, now exports a multi-entry SSA2 IL.  This is the
culmination of:

b18ade8 Convert SSA2 Simplify to the multi-entry SSA2 IL (partially)
ef08b4f Convert the SSA2 Shrink functor to the multi-entry SSA2 IL
18a4ab5 Convert the SSA2 PrePasses functor to the multi-entry IL
35d9463 Convert the SSA2 type-checker to the multi-entry SSA2 IL
0abb7bb SSA2: Convenience functions for finding 'main'
0dc5617 Convert SSA2 Analyze to the multi-entry SSA2 IL
f0c14c5 Copy SSA2 passes needed to convert ssa2.fun to multi-entry
ec83d53 SSA2: Make 'main' a FuncEntry, not a Func
226a879 Convenience functions for SSA2 FunctionEntry
ca444d0 Fix dominatorForest calculation for SSA2
229c90e Add multi-entry functions to the SSA2 IL
Copy the SSA -> SSA2 transform; make room for ME_SSA -> ME_SSA2 transform

As with the other "Copy Foo" commits, this is a temporary copy to keep
around the old pipeline while preparing the new, multi-entry pipeline.
Add sharing contstraints for FuncEntry to Atoms signature

Now 'FuncEntry's from different ILs (e.g. SXML and SSA) will be the
same type.
Convert SSA-to-SSA2 to the multi entry SSA/SSA2 ILs
Add the multi-entry SSA2 IL to the multi-entry pipeline
Add the SSA2 IL to the CM build
Copy existing RSSA IL to make room for multi-entry RSSA

Copy the RSSA IL so that the existing pipline can continue to run while
the multi-entry pipeline is being set up.  This commit will be reverted
when the new pipeline is set up.
Add multi-entry functions to the RSSA IL

The conversion process was similar to adding multi-entry functions to
the SSA and SSA2 ILs.

Most of the conversions were just generalizations of already iteratively
defined actions, such as running a function on all of the arguments of a
function or marking which blocks in a function are reachable by doing a
depth-first-traversal from the start.

Changes that stuck out:

- A new transfer, 'Bug', was added, to accommodate the construction of a
  fake block to dominate all of the entry blocks of a function.  To do
  this, the fake block needed some form of transfer.  I wanted to create
  as little fake data as possible, so I wanted to use a nullary
  constructor --- hence 'Bug'.  A similar thing could have been done
  with Kind, but Kind.t.Jump was already a nullary constructor and
  seemed to fit well enough.

- Rssa.Program.main has a new type: {func: Function.t, entry:
  FuncEntry.t}.  This type is different from the type for 'main' in SSA
  and SSA2.  The record type was chosen because there were many cases
  where accessors wanted both "main, the collection of blocks" and
  "main, the label to jump to".
  This access behavior was also in SSA and SSA2, to a lesser extent,
  where main is just a FuncEntry.t.  If accessors want "main, the
  collection of blocks", they have to do a linear search through all of
  the functions -- so SSA and SSA2 may have their 'main' converted to
  the type RSSA now uses.
Copy SSA2-to-RSSA files, making room for multi-entry versions
Port ssa2-to-rssa to the multi-entry function ILs

This conversion was mostly straightforward, since only functions and
transfers have changed.

One part of this change makes me uneasy: the conversion for 'main'
seemed a bit out of the ordinary, since it creates a new SSA2 function,
which points to the existing SSA2 'main', then transforms the new
function into RSSA, saving the new function as RSSA's 'main'.  Keeping
track of which labels needed to go into the new entry point and the new
transfer was confusing.  I think this is correct, but unfortunately, I
won't be able to test it until the rest of the backend can be added to
the main compilation pipeline.