Only rematerialize instructions when its safe to.

Only rematerialize an instruction if its inputs are still live
and in registers at the point we're cloning it, which, given the current state of flux in the register allocator, is restricted for
now to just instructions that consume rVmSp, rVmFp, or immediate constants.
Minor tweaks to StateVector @override-unit-failures

- Move to state_vector.h
- Use smart::vector instead of std::vector
- Make factoryId and count helpers private
- Add const_iterator support
- Make grow() use resize() instead of looping push_back().
- Use assign() in reset().
Add a OpNot to HHIR; remove TraceBuilder::genNot

There's always been a little weirdness in the simplifier with
regard to negation.  Apparently I used to think it could lead to
losing a ConvToBool (I am not 100% sure what the case that comment
refered to was now though).  It definitely lets us avoid some
zero-extending bools to ints though (since our binary arith guys don't
support bools yet), and with this the last "dubious" genFoo is gone.
Move remaining stack optimizations to simplifier

Removes all their genFoo functions and does the corresponding
work in Simplifier, since it requires no state.
Fix trace exit type for IncDecL of boxed values

For accesses to boxed locals, if the inner type changes, we can
retranslate using HHIR: the new translation will inspect the live type
and be able to execute the instruction.  While looking at something
else, I noticed that in such cases IncDecL was taking a slow exit
(which avoids using HHIR).
Improve the Next command to not interpret and single-step ever line under calls from the original source line

This improves both Next and Out to avoid interpreting and stepping everything between when they start and finish. Out now lets the program run free until a pseudo-breakpoint at the return site it hit. Next continues to single-step the source line being stepped over, but now lets the program run free under calls made from that line.

The logic in Next regarding "calls made from that line" is extremely generic. We don't look at, say, call opcodes and decide to do something special. Rather, when we find we're off the original source line and a frame deeper we setup a "step out" operation much like the Out command then let the program run free. When we reach our return point, we continue stepping like normal. This accounts for not just calls, but iterators, and anything else that causes more PHP to run under the original source line.

This change moves the flow control logic down in to the respective cmds: Next, Step, Out, Continue. These cmds get a crack at executing at various points in the interrupt/command processing path. These cmds now own setting up the last location filter, whether they need VM interrupts, and whether they're done or not.
Fix runtime options for tests

My diff to turn the ir on by default missed a few places that
need HHIRDisableTx64=0.
Disable some zend tests reported as flaky
Use traceRelease for Eval.DumpBytecode

This shouldn't be restricted to debug builds.
Streamline exits from HHIR to Interp when Tx64 is off

If Tx64 is disabled, change slow exits to call the interpreter directly.
Minor cleanup in srcdb.h

Mainly gets rid of the need to pass Asm& a and astubs
to all the patching functions.