Transceiver: explicitly declared destructor

The destructor for Transceiver is now explicitly declared so that
the compiler won't synthesize one.
When dealing with PIMPLs, synthesized destructors are simply not
feasible.
Session, request: refactor design

Refactoring of Request:

Request has been modified so that there is a common base class,
a *specific* templated class for interfacing with Session, and a
buffering class for raw HTTP CGI.

Namely, the main class is Request_base, with virtual
{params,in,data}_handlers (both low-level and post-handlers) that
allow for overriding.
The addition of params_handler allows us to hook the per-request
setenv's. Namely, if the hook simply returns false, we can have a
completely blank environment. We can also use the hook to parse
specific env vars (params), keep the parsed version, and discard
all the other ones.

The environment list was moved out of Session_base and into
Request_base, and Session_base only stores the parsed variables.
The buffering of the params handling is still preserved, so there is
zero functional difference in terms of PARAMS handling.

For a simple buffered handler, use Request<postvec_t, datavec_t>.
For parsing the "output" of HTML forms, use
Form_request<charT, postvec_t, datavec_t>.

Another advantage of the refactor was that the bulk of the Request code
didn't need to be templated anymore, so we can place the common code in
src/ and save on compile time.

Refactoring of Session:

Fcgi_session has been deemed redundant, and Form_request, deriving
from Request, has the replacement functionality.

The params parser has been modified to parse one env-var pair per
invocation, instead of the whole list.
Note: it does not discard any parsed env pairs - they are still
available in (( : Request_base )).envs.

The params parser has been moved out of Session_base and into
Request_base. Since the params parser only uses std::string, there's no
need to keep it in the headers.
Locked: template wrapper for lock-augmented types

Adds two templates:

Mutexed<T>, which allows an object to associate a mutex with it without
introducing a second variable
Mutexed_0<T>, Mutexed<T> for POD types

Rw_locked<T>, which allows an object to associate a readers-writer lock
with it without introducing a second variable

Note: locking semantics are *not* introduced. You must still explicitly
lock and unlock as needed.
However, seeing as these are derived from Lockable types, they can be
passed as arguments to std::lock_guard<std::mutex> /
std::lock_guard<Rw_lock>.
Add missing headers in src/
include/Makefile.am: fixups in 'clean:'

Old 'make clean' used to die if the dummy file wasn't found.
To work around this, rm -f is used.
An alternate solution would be to use sh -c ' [ -f ... ] && rm ... '.
Transceiver: add definition for explcit dtor
http::Converter: add reset function

Converters can now use a reset() function for resetting the encoder
state.
Plans include to add a finalize() function for finalizing state (this
is only for stateful encoders, e.g. base64 with end-of-stream padding
and 72 chars per line).
http/session: remove extraneous #include

Remove the extraneous '#include
<mosh/fcgi/http/session/fcgi_session.hpp>'.

My bad; I should've committed this as part of
45e1ac28f734c98dcbb18d6c5bd0caf40ba703c5.
http/misc: add support for tm and timeval

Add struct tm and struct timeval overloads for time_to_string.
protocol/Full_id: change Full_id union type

The union type is now uint64_t, for cases where an fd is >65535.
Truncation of the fd value would be a Bad Thing, so we update the
structure to hold both the 32-bit conn fd and the 16-bit request id.

However, there are 2 unused bytes now.
manager: refactor

Manager has been refactored into Manager and ManagerT.

Namely, Manager makes use of Request_base's virtuals and stores pointers
to instances. The virtualness of the dtors prevents memory leaks.
Now, it's template-invariant and the implementation can be moved to
src/.

With the implementation of the per-request management moved to src/, the
library-general portions of management are moved here, too, namely
GET_VALUES handling, which has been moved from src/protocol/funcs.cpp.

The constructor for Manager is
Manager(int fd, std::function<Request_base * ()> new_request).
Because
Manager x([](){return new T;})
can get tedious and ugly, ManagerT<T : Request_base> is defined, which
templatizes the 'return new T;'. Type_traits magic is used to restrict
ManagerT's <T> to only instantiate subtypes of Request_base.

Manager also has a unified signal handler. Since there's only one
Manager instance per process, we can use a global map of pid->Manager*
to co-ordinate all the instance pointers.
Now, it uses the result of getpid to find the correct instance for which
to call .terminate() or .stop().
Pid->instance* registration is done in the constructor and
deregistration in the destructor.
To avoid UB, an assertion is done to ensure that the pointer is
non-zero.
examples: echo: rename html file to echo.html