Limit the number of blocks handled by TraceBuilder::optimizeTrace

It appears to be O(N^3) in the number of blocks (a quick glance
at the code suggested N^2, but 1000 blocks took about .5s to process
while 2000 blocks took 4; 19000 blocks was nowhere near finished in
an hour). A better representation of the dominators would probably
solve this - but would also take *much* more space.
Having more than 1000 blocks appears to be extremely rare, so
this seems like a reasonable solution for now.
Simplify classof

We dont need to check whether the first Class* is
an interface or trait.

If the second class is an interface or trait, we
take the slow path. Otherwise, we take the fast path,
which will always return false if the first class is
an interface or trait (its m_classVec can only contain
interfaces or traits, while cls's m_classVec can only
contain non-interfaces and non-traits).

This saves doing the check, and avoids the slow path
in the case where the class being tested  is an interface
or trait.
Reenable direct branch patching for ExitTraceCc

It looks like the pattern-matching performed in
hoistConditionalJumps() was not updated when control-flow support was
added, so the optimization was missing opportunities.
Fix emitInterceptProlog

When the compare was rewritten for the new assembler syntax
it was accidently changed from being a compare of the byte
pointed to by rax, to a compare of the low byte of rax.

I also noticed that by loading the Func* into rax, and doing
a compare against rax[Func::maybeInterceptedOff()] we can
skip a subsequent mov of the Func* into rax.

The code was only slightly broken because we set everything
to be interceptable up front, (if EnableRenameFunction is on)
because we had too many issues with the invalidation code. The
bug was that if the Func happened to be allocated at a multiple
of 256 bytes, it wasnt interceptable.

Also, the existing code looked silly,

  mov  $abcdef45, $eax
  cmp  0, $al

and the new code is smaller.
Collections updates

Replace "collection" with "collections" in various file names since
we typically use the plural form in conversation and documentation.

Add set() and removeAt() methods needed for collection interfaces. Also
add the KeyedIterable and KeyedIterator interfaces.

Add __construct() methods for collections
Minor assembler enhancements.
tell closures about scope clones

In HHBC mode, traits are flattened into their classes.
When that happens, closures need to know about all the
classes that contain them so that when we find a ##$this##
inside the closure, it can tell EVERY containing scope to
please propogate ##$this## down to me.
Use lookupUniqueClass

The translator does better in a number of places when it
knows an AttrUnqiue Class* at translation time - even if it
doesnt know for sure that it will be defined when we enter the
tracelet. Now that we autoload (nearly) everything, we enter
a lot of tracelets where an AttrUnique Class* has been seen
(during warmup) but is not yet defined (in this request).
I added lookupUniqueClass while working on the new autoloader
to find such Classes, and allow us to do a better translation,
but never got around to using it.
Properly patch exit traces ending with JmpZero and JmpNZero

The hoistConditionalJumps pass was not handling traces ending with
JmpZero and JmpNZero.  This was resulting in spurious jumps to
'astubs' instead of patching the jcc+jump pair in 'a'.
Add new DestType enum for helpers that return TypedValue.

This is necessary because without it, the only clue we have about
what return type a helper has, is the register assignments of the
destination SSATmp.  It is possible that even though the helper returns
a TypedValue, we might only have dest registers assigned for one part
or the other part.

Lastly, we could end up having helpers that return other two-register
results, which shouldn't be confused with TypedValue.

Also fixed cgFCallBuiltin() to use the correct size test
instruction when computing on types.  Types are currnetly 32bits
and the other bits can be garbage.

Renamed ArgGroup.valueType() to typedValue() for clarity.  It's only for
passing TypedValues by value; other register-packed structs would
need new helpers.

Added more asserts in cgCallHelper based on the return type.
assert if we assigned a register but DestType implies there's no
such value (e.g. assigning a void return to a register).