- Split the gigantic <tao.h> header in smaller headers.
- Make most structures opaque. Structure definitions are in
  <tao-*-private.h> headers.
- Reduce the number of rebuilt files when a header is modified.
- In code, TAO headers should be included first, then "config.h" (if
  needed), finally standard C headers.
- Eliminate compatibility code for Booleans (trust <stdbool.h>).
- If one is lazy, <tao.h> can be included; but it is generally
  sufficient to include a subset of the TAO headers.

The idea is that a deformable mirror server shall manage 3 resources:

- a device driver (specific to the type of mirror);

- a remote mirror instance to communicate with clients;

- a shared mirror data instance to provide telemetry data;

Standard C imposes that names prefixed by `_` and types suffixed by `_t`
are reserved).  Hence:

- Public symbols and macros are prefixed by `tao_` and `TAO_`.

- Private/helper symbols and macros are prefixed by `tao__` and `TAO__`.

- Types are no longer suffixed by `_t`.

- `struct`/`enum`/`union` have the same name as their `typedef`
  counterpart.

- Headers define a macro `TAO_..._H_` to avoid being included more than
  once.

TAO_ALIGNEMENT is set to 64 bytes, the cache line size.

This results in an enormous number of changes but it makes the code more
consistent and, hopefully, easier to read/understand.  The code statements
have been mostly left untouched, the libraries compile and all tests that
do not require access to a device were successful.

Shared objects are built on top of `tao_shared_data_t` instances which
provide a mechanism for r/w locking the resource.  The code for
finalizing shared resources is simpler because we can assume that
the mutex associated to shared data is always owned for a short period.
This will also simplifies getting images from a remote camera: semaphores
will no longer be needed (code compiles but is broken for now in that
respect).

Most functions return a `tao_status_t` to represent success, error or
timeout.  This simplifies and unifies calls to functions with a duration
limit.  This makes the code more clear about the intention:
`foo(...) == TAO_OK` is much better than `foo(...) == 0` or, worse,
`!foo(...)`.