Add AISyncClient<> (and AISyncServer).

A tool to synchronize objects:
Objects derived from AISyncClient can signal that they are
'ready' or 'not ready' for up to 4 events (using a bitmask)
at a time. Clients that signal to be ready for anything
at roughly the same time as other clients, and which return
the same 'hash' (a virtual function returning a 64bit value)
will be grouped together and receive events (by means of
virtual functions being called) to notify them of all clients
being ready or not for one of the events (syncevent1).
The other three events can be polled.

The memory usage is low (one pointer per client that points
to its AISyncServer object), servers are released to a cache
after about 100 ms (unless there is actual need for synchronization),
so there aren't much of those either.

The CPU usage is extremely low: all events are handled in
parallel in a 32 bit value (6 bits per event to count the
number of registered clients and the number of ready clients
for each event, and the remaining 8 bits to count the
number of reference pointers (which should only be a constant
higher, so that is overkill). To signal to a server that
a client has become ready or not is mostly a function call,
which then takes 1 clock cycle or so before returning.
Registration of a client is slightly more expensive as it
requires a pointer to be added to the end of a std::list.
This tool could easily be used as part of the graphics engine
(not that I intend to do that :p).

indra/llcommon/CMakeLists.txt

@@ -20,6 +20,7 @@ set(llcommon_SOURCE_FILES
     aialert.cpp
     aifile.cpp
     aiframetimer.cpp
+    aisyncclient.cpp
     aithreadid.cpp
     imageids.cpp
     indra_constants.cpp
@@ -112,6 +113,7 @@ set(llcommon_HEADER_FILES
     aifile.h
     aiframetimer.h
     airecursive.h
+    aisyncclient.h
     aithreadid.h
     aithreadsafe.h
     bitpack.h