Convert ImplementProfiling to multi-entry.

No significant difficulties with the conversion.

However, one feature of the single-entry ImplementProfiling has not
been converted.  The original ImplementProfiling searched for the
first Enter statement encountered in a depth-first traversal (from the
'start' label) and moved it to the beginning of the 'start' block.
This was added by commit 7c1e382 for code coverage reasons.  Often,
code is added to the "beginning" of a function by introducing a new
start block (and possibly additional blocks) to preceed the old start
block; for example, limit checks and signal checks insert checks at
the beginning of a function in this manner.  By moving an Enter
statement to the beginning of a function, this added code is "charged"
to the current function.

This approach does not suffice for multi-entry, since different entry
points could have different first Enter statements.  (In particular, a
proposed multi-entry optimization that merges tail-callers/callees
into a single function would result in different entry points with
different first Enter statements.)  The invariant of properly nested
Enter/Leave pairs could be violated if a single Enter were moved to
the beginning of each entry point's 'start' block.

Furthermre, It is not clear that this approach suffices for
single-entry, since it is not necessarily the case that the first
Enter statement encounted in a depth-first traversal (from the 'start'
label) is the the first Enter statement encountered in every path from
the 'start' label.  Such a condition is not required by the SSA/SSA2
checking of profiling expressions.
Add even-odd benchmark.

Add a new even-odd benchmark that exercises mutual tail recursion.
Note that it is important that both "even" and "odd" are called from
the main program; if only "even" is called, then the Contify
optimization will move both "even'" and "odd'" to their one return
point and turn the tail recursion into a local loop.

A forthcoming MergeTailCalls optimization will merge the "even" and
"odd" functions into single function with two entry points; then
IntroduceLoops will eliminate the self-tail calls in favor of a local
loop; then InlineNonRecursive will (most likely) be able to inline the
resulting non-recursive function.  Even if the function is not
inlined, turning the tail calls into a local loop will be a
performance win.
Update benchmark iteration counts.

Increase the benchmark iteration counts so that all benchmarks run for
at least 15 seconds (for amd64-linux on an "Intel(R) Core(TM) i5-3570K
CPU @ 3.40GHz").

Added an "update-counts.sh" script to calculate appropriate benchmark
iteration counts.

Ideally, the benchmark iteration counts should be loaded dynamically
at the time the benchmark suite is executed (rather than being
hard-coded into the benchmark suite executable).  Then, it would be
easier to calibrate appropriate benchmark iteration counts for
different machines.
Updates to the benchmarking infrastructure.

* bbf87d1 Add an even-odd benchmark to exercise the optimization of
          mutually tail recursive functions
* 34b2958 Increase the iteration counts of benchmarks to obtain
          non-trivial running times.