Add some initial classes for FlightVars.
Move all code to STL coding standards.
Fix some style issues. Add artifacts for FlightVars protocol handling.
Move buffers and streams from inheritance/polymorphism to template approach.
Add classes for TCP client and server.
Add variable subscription capabilities for FlightVars server.
Add a new class async_executor which executes actions asynchronously from one designated thread
Add a new utility class shared_by_ptr to facilitate pointer handling.
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.