rejigger systemlib

I've always been a bit sad about having all classes in the same file to govern inclusion order. And the filenames didn't match the class names.

Instead, lets not rely on whatever order `find` returns, and instead hard-code the ordering of the system lib. I grouped the files by what extension they came from.
Move runtime/eval/runtime/file_repository.* to runtime/base

runtime/eval is a relic of a bygone era. As long as we're cleaning up
our directory structure, let's move FileRepository (the only remaining
thing in runtime/eval/runtime) to where it makes sense.

runtime/eval still contains the debugger, which would probably make more
sense as runtime/debugger, but I don't want to throw a wrench in the
works for @mikemag and @hermanv unnecessarily.
Fix step out bugs (also effects Next)

We had a lot of odd behavior with both Next and Out. Previously the debugger would interpret the world until it saw that it was no longer on a specific line, or at a specific stack depth. I changed it recently to let the program run normally, and use an internal breakpoint to control step outs. Next's become like a step out temporarily when you descend into a function and need to get back out to the original line, so some bugs with out showed as bugs with Next, too.

Specifically, any time more PHP code was executed as a "side-effect" of a non-fcall instruction, step out would get lost. In these cases the stack trace gives us the offset of the instruction causing the PHP to run, not the instruction that control will return to as is the case with a Fcall. A breakpoint set there would get missed. This changes the step out logic to recognize such cases (via the fact that a nested VM state was pushed to execute the code) and step out more intelligently. We look at the instruction in question, and determine where execution may go, which might be multiple places. I also made a small change to ensure that we don't stop in generated functions when stepping out, which cleans up the iterator experience quite a bit, and sets us up for proper generator stepping, which will come next.
Move runtime/eval/debugger to runtime/debugger

runtime/eval is now gone. Woooo

This is just a git mv + `codemod runtime/eval/debugger runtime/debugger`
Remove generated generator function name from test

Get the generated function names out of the test output.
Fix overloading issues with Variant::nullInit

After Variant::Variant(NullInit) was made explicit, passing
Variant::nullInit to a function expecting CVarRef, or Variant
would actually call Variant(0), with ensuing hilarity.

Make NullInit an enum class to prevent such issues.
overrides need to come after defaults in test/run

- reverse order of default and test args so test args override
Fixup lots of include paths

This fixes most remaining paths to be relative to the git root.
resolve potentially global namespaced functions

When we see `define('Foo', 'Bar')` in a namespace, we don't know if it is talking about the global define function or the a local namespace one. What should we do? Does marking constants Dynamic that aren't actually dynamic break anything? Without this, HPHP creates a creates a CodeError.js

Closes #771
Remove immstack.cpp

It's dead but I missed it in my previous diff
fix parser tests

I was quite stupid in my rewrite and totally broke this. Wow, it runs fast!

I had to switch to `HHVM_BIN` as the env var, since it seems we force `HHVM` to 1 all the time...
Fix parsing for generic constraints with the "as" keyword

For generic constraints, the grammar (incorrectly) did not allow for
generic types on the right hand side of the "as" keyword. This diff fixes
the grammar appropriately.
Kill m_should_throw

Do not check for m_should_throw from ContReceive. Add a label used by
ContRaise pointing to Throw emitted by the Yield instead.
refactor RequestHandler behavior

This refactors the RequestHandler code, to decouple RequestHandler
behavior from the Server implementation.  The goal is to make it easier
to define additional Server implementations, in addition to just
LibEventServer.

This adds a RequestHandlerFactory function, rather than using a pure
virtual method of the Server class.  With the old model, you had to
subclass each server implementation separately for each RequestHandler
type you wanted to use, resulting in NxM classes if you have N server
types and M request handler types.

This also changes the behavior of the RequestHandler class somewhat:
the code now only creates a single RequestHandler per thread, and uses
that object for all request in that thread.  Previously the
LibEventServer code would attempt to create a new RequestHandler object
for each request if supportReset() returned true.  This was used by
RPCRequestHandler.  Now the RPCRequestHandler instead just resets itself
automatically when necessary, without requiring external help from
LibEventServer.

contbuild test runs failed due to git server issues.
replace Server::shouldHandle() with a std::function

Change the Server API so that users don't have to subclass it in order
to override shouldHandle().  Now users can specify a custom
std::function for checking allowed URLs.

This will make it easier to provide alternative Server implementations.
Previously InternalPageServerImpl had to subclass LibEventServer in
order to override shouldHandle().  This tied the code to LibEventServer,
so that it could not be easily changed to an alternative implementation.

It seems like this URL checking functionality should perhaps be moved
into the RequestHandler.  However, for now this is a simpler change.
move addTakeoverListener() to the Server API

Make addTakeoverListener() part of the top-level server API, instead of
being specific to LibEventServerWithTakeover.  Servers that don't
support socket takeover simply ignore this call.

This will allow future server implementations to support socket
takeover.  This also allows us to start making the server creation logic
in HttpServer a bit more generic, since the code can always call
addTakeoverListener() without having to know if it really has a
LibEventServerWithTakeover or some other type of server.
move warmup thread functionality out of LibEventServer

This moves the warmup thread logic from LibEventServer to a new
WarmupRequestHandler class.  This will allow the logic to work with any
server implementation, since it isn't really specific to LibEventServer.
(Eventually it would perhaps be nice to decouple the worker thread
behavior from the server I/O implementation entirely.)
add a ServerFactory class

This refactors the Server creation code, to make it easier to create new
Server implementations in the future, and to separate the LibEventServer
code from the main hphp_runtime library.

This defines a new ServerFactory interface, and a ServerFactoryRegistry
which maintains a mapping of server type strings to ServerFactory
objects.  The HttpServer code now uses a ServerFactory to create the
m_pageServer, rather than directly creating a LibEventServer object.
Smaller c_Continuation

Save 16 bytes in c_Continuation by moving running and done flags to o_subclassData and making labels 2-byte.
Embed ContReceive into UnpackCont

Hoist ContReceive to the beginning of continuation body and make it part
of UnpackCont. This is a preparation for passing m_received thru the
stack.