Start a set of C++11 lambda-oriented bindings.

This patch only wraps lo_server and lo_server_thread.
Add a means to bypass LO_MARKER checking if type string ends in "$$".

Although the LO_MARKER trick allows a neat run-time check for
lo_send() argument correctness, sometimes when passing on varargs from
another function it can make things difficult, since it depends on a
macro that appends the LO_MARKER arguments.

For example, in the C++ bindings, we wish to define a function named
"Address::send" which passes its arguments on to
lo_message_add_varargs(), however defining a macro called "send" is
not a good idea.

Without changing the prototype for lo_message_add_varargs(), the only
way to disable this check is by modifying one of its existing
arguments.  Therefore, this patch adds a check for two consecutive '$'
characters in the type string.  If they are found, the LO_MARKER check
is bypassed.

Unfortunately this means that a calling function must supply a copied
and modified type string---in a future version of the API it would be
good to give lo_message_add_varargs() the means to disable this check
explicitly.
Add an Address class
Cast operators to liblo types.
Add a Message class.
Add send_from for lo_message.
Ensure not to initialize std::string results with null.
Get rid of debug messages and fix superclass constructor calls.
Turn on -Werror in CXXFLAGS, and fix a few warnings.
Add a handler type for path+msg.
Add a Blob class.
Add a Message constructor that allows adding arguments.

This allows expressing message construction and sending in one-liner!
Add a Bundle class.
Add an ownership flag to Message.
Add a function to send a no-arg message.
Add a wrapper for lo_message_pp().
Use the Message class in handlers instead of lo_message.
Implement method deletion.

Required changing the vector used to store handler wrapper functions
into an unordered map of lists indexed by the path and typespec of the
method.
Enforce ownership semantics statically by a bool template for Message and Bundle.

For instance, the compiler can now verify that Bundle only takes
ownership over messages that do not have ownership.  Otherwise
double-frees can easily occur when constructing temporary Messages on
the stack and passing them into Bundles.

It would be better to have a concept of ownership *transfer*, like
std::unique_ptr.

The syntax is not as clean due to this template argument, but forcing
the user to think about ownership is probably overall a good thing,
since it can easily lead to leaks and crashes.
Add an error handler that takes std::string instead of char*.