Add more server-side debugger logging, small tweaks to server-side error paths

Added some more logging on the server when debugging. Log warnings during shutdown (normal and from the signal handler) when there are debuggers attached. Minor tweaks to some of the error handling paths, with more log messages instead of silent failures. Also moved server-side closing of the thrift buffer to proxy destruction.
Remove Array::operator[](litstr)

Refactor the remaining uses of litstr-indexed Array, and
get rid of the operator overload.
Stop boxing everything in the JSON parser

The JSON parser was producing structures that held all arrays in
RefData. This was to defeat copy-on-write, since ArrayDatas were
referenced from multiple places (i.e. the parser's internal stack of
in-flight objects, and the actual structure being built) and mutated. I
rectified this by not adding arrays into the overall structure until
they're done being modified. This necessitated introducing a separate
stack for keys, to handle this structure:

  { "key": { ... } }

When we see the opening { of the inner object, we push "key" onto the
stack, so that when we see the closing } of the inner object, we can
store it into the outer object under the right key.
Minor improvements to ArrayInit

Remove implicit conversion operator.  Also found some apc
code that relied on copy elision for correctness.
Make a toVariant() function on ArrayInit @override-unit-failures

Suggested by @smith.
tx64's vector helpers are no longer hot

This is cheating wrt tx64 vs. hhir but that battle's already
been decided. We should be able to just remove these completely soon.
Tune some VectorTranslator helpers

vGet*Impl were always returning TypedValues with m_type ==
KindOfRef so I just made them return RefData*. cGet*Impl were doing
some unecessary copying of TypedValues.
Fix is_object on resources

PHP certainly never runs out of fun surprises to spring on me!
Implement IsObject in IR

It turns out is_object actually shouldn't be calling isResource, so this
really wasn't as bad as everyone thought. I cleaned up the simplifier
logic for this instruction (even though is_object is weird, we can still
optimize it away when the src isn't even KindOfObject).

A more elegant solution might be to introduce Type::Resource, but that
would be more complex and I just want to get something working for the
purposes of lockdown.
Use equals() in equals(StringData, StringData)

Equals is faster in a few ways.
(1) no call to memcmp unless string sizes are the same
(2) does a fast check for either of the strings being static
    before any calls to is_numeric_string
Rewrite parser for break point specification.

The specification string following a break command was parsed by means of ad-hoc string splitting and sub string finding. This scheme cannot deal with namespaces and class names that contain : (such as xhp classes). There is now a proper parser for break point specifications. Also, xhp class names are mangled before putting them in the BreakPointInfo structure, otherwise breakpoints qualified with xhp classes will not be hit. The syntax for namespaces has been changed to fit the language and if present namespaces are used to mangle function and class names, so that they match the names produced by the regular parser.
Implement fast allocation path for objects in HHIR

Tx64 generates a fast path for allocating objects of a
persistent class that inlines a bunch of the helper work into the TC.
This diff is basically a translation of that path into HHIR codegen.
Use target cache for static properties of persistent classes

Accessibility of properties of persistent classes can be checked at JIT
time, so use the SProp-based fast path for these cases too.

Also, enhance HhbcTranslator to try to emit LdClsPropAddrCached,
instead of relying on the Simplifier to transform LdClsPropAddr into
LdClsPropAddrCached.  Doing this only in the Simplifier results in
unecessary ExceptionBarrier before LdClsPropAddrCached.  However,
there's still value in keeping the optimization in the Simplifier, so
that it can leverage opportunities exposed by other optimizations.  So
factor out the logic to check whether to use the SProp cache.
fix flakey test

scanning the current directory sucks
Improve readability of break point code in debugger.

Added comments to every method in cmd_breakpoint.cpp. Also renamed some methods to make their intent more obvious. Moved a few implementation methods from the public to protected space.
Remove Variant::operator[](litstr)

And its remaining call sites.
Disable the debugger's Instrument command, and remove the code that checks for instrumentation from the interpreter

The debugger's Instrument command does not work with the JIT; any instrumentation requests will be ignored for jitted code. We believe that no one is using this at this time. I'm starting with a small diff to disable the command and remove the impact it has on the interpreter for now, just in case we're wrong. Once the command has been disabled for a few weeks I'll come back and remove all of the code (task 2376711).

InstHelpers was just pure dead code, so I nuked it.
Fix bug with preventing returns to TC for debugger

In order to ensure that we can continue to interpret code when setting up a step out, even if we're stepping out to jitted code, we set the saved RIP in each ActRec on the stack to the retFromInterpretedFrame() helper. However, this is wrong for generator functions. There is a different variant of the function for generators, so use that when appropriate. Also added a check to ensure we only changed return addresses to jitted code. Mark thought of a rare case where we could have a return address to a C++ helper in there, so leave those alone.
Localize MySQL.Localize option to Facebook build only

This extension to the mysql php-api relies
on internal libmysqlclient functions which are deprecated
from normal MySQL builds.  Just turn it off and use fallback
behavior instead.