Continue working on ServerKit

- Fixed some bugs
- Added some optimizations
- Added support for HTTP upgrades
- Added support for HEAD requests
- Added JSON introspection and configuration
- Allow parsers to be reusable with non-BaseHttpRequest objects
- Refactor client/request object de- and reinitialization
ServerKit: optimize lowercase conversion function

It's now twice as fast.
Optimization: use boost::container::vector instead of std::vector in ApplicationPool2 for post lock actions

The Boost version does not allocate memory in its default constructor.
Optimize the priority queue in ApplicationPool2.

Replace the fibonacci heap with a d-ary heap. The former is an in-place data
structure that's backed by a vector, and thus has great CPU caching behavior.
This makes it perform better than a fibonacci heap despite worse algorithmic complexity.
Temporarily remove travis.yml
Remove mutex from FileChangeChecker and CachedFileStat. We don't need them to be thread-safe
Optimize ApplicationPool2 GetCallback

Use a simple struct functor instead of boost::function.
This is much faster.
Optimize ApplicationPool2 needsRestart()

Apparently CachedFileStat and FileChangeChecker are slow.
Fix pushWaiter() in ApplicationPool2

It may not call the callback inside the lock
Replace weak pointers in ApplicationPool2 data structures with normal pointers

Weak pointers aren't necessary anyway because containing objects outlive
children objects. Using normal pointers reduces the number of reference count
changes.
Session object pooling
Optimize Options: use initializer list in constructor
Optimize time queries in ApplicationPool

Allow passing cached timestamps to ApplicationPool methods.
This saves some time querying calls.
Embed refcount into Session and use intrusive_ptr
Optimize ApplicationPool priority queues

This is done by increasing their arity. This improves CPU cache locality
despite needing more comparisons
Embed SocketList directly inside Process, instead of using a smart pointer. This removes an indirection
Store some ApplicationPool strings in a palloc pool

This improves cache locality compared to using std::string, which stores
string data on the heap.
Change ProcessList into a vector for better cache locality and less indirection
Get rid of the priority queue for processes.

Replace it with a simple linear search, which is faster than heap management.
Put process busyness levels in a compact array so that the linear scan is very fast for large numbers of processes.