Add a async_tcp_server class for asynchronous TCP serving.
Add ring buffer class

Asynchronous IO is pretty related with ring buffers. For
stream-oriented protocols where message size cannot be determined
before read, it is pretty important to have the capability to read
as many bytes as available until a new message can be deserialized.
After that, there could be remaining bytes that belong to the next
message. Those bytes have to be retained, and there is where the
ring buffer comes into action.

This change adds a new StreamBuffer class named ring_buffer, and
adapts the asynchronous TCP server to use StreamBuffer, allowing
a client to use a ring_buffer for stream-oriented communications.
Reimplement FlightVars server as async tcp

FlightVars TCP server was using synchronous IO for handling the
messages. After this change it now uses async_tcp_server class as
for asynchronous IO.
Extend FlightVars protocol with var update msg

Now the protocol supports (de)serialization of var update messages.
Introduce a new FV entity: variable ID

There are several parts in the code where the pair of var group
and var name are used. In order to reduce this boilerplate code,
a new entity is introduced: the variable_id type. This is just a
std::pair or var group and name, with convenience functions to
handle it. In a future commit, the API will be refactored to use
variable_id instead of splitted var group and name arguments.
Add a new subscription_mapper class for FlightVars

This class is useful to handle the mapping between variable ID
(var group and name pair) and the subscription ID. It will be
consumed from the FlightVars TCP server and client to track the
variable subscriptions.
Refactor FlightVars API to use variable_id

For subscription and var update handler, the code was using two
arguments of type variable_group and variable_name. These args can
be safely replaced by one value of type variable_id, which provides
the same semantics in only one object.
Make subscription_id a outer level entity

So far, subscription_id was a type declared into flight_vars class.
Since it is given the same importance and treat as variable_name,
variable_group, variable_id and variable_value, it deserves to be
a outer type as the rest.
Move some private declarations to inl file

For FlightVars protocol, some private declarations that are only
needed by the public functions it exports were declared in the
header file. These declarations are moved to the inline header file
from now on.
Fix several bugs in linear_stream_buffer_base

In async_read_some_from() and async_write_some_from() a invalid
expression was used to describe the handlers. For async_read_some_from(),
a write ASIO buffer was used rather than the correct read buffer.
Fix a compilation bug in shared_by_ptr

The zero-arity version of shared_by_ptr::create was trying to
initialize the Pointer type (defaulted to std::shared_ptr) with
a naked pointer. This constructor is explicit for std::shared_ptr,
so the naked pointer have to be wrapped by Pointer before return.
Make flight_vars_server send var updates

Now flight_vars_server is able to send var update messages.
Fix some building issues

Issues related with WinSocket.h and Windows.h includes appear again
in Boost 1.54.0. This commit defines the macro WIN32_LEAN_AND_MEAN
before every include statement for Windows.h header, finally fixing
the issue.

FSUIPC SDK building is a real pain. The latest version that may be
found in the website lacks the MSVC project file to regenerate the
library. So a extreme decision has been made for that: include the
FSUIPC user code into OACSD codebase. A new fsuipc subproject is
added, which contains the source code of FSUIPC User Internal with
an additional copyright note indicating who are the owners of these
files. This is fully compliant with both the GPL license and the
public domain status of FSUIPC SDK. We may expect not to have any
further issue with this dependency anymore.