It's difficult to debug when using random uuids.  Added a mechanism
for getting just incremented uuids from util when debugging.
Creating a separate thread pool shared between all endpoints.  This
thread pool will be used to process service actions.
Following Harrison's suggestion, creating threads is expensive, and it
would be better to share threads across endpoints in a common pool.
Uncertain of locking on active event map's _map method.
Commit does a few things:
  1) Separates boosted promotion into service action.  Breaks
     potential deadlock of holding lock on active event map and
     boosted events.

  2) Undid commit that allowed application exceptions to fail
     silently.  It's a debugging headache because it might be that the
     backend libraries through the exception, not the Waldo-written
     code.
Added class for debugging: after some period of time, lists all outstanding events in the system's event maps.  Can be used to find deadlock.
Added a debugging monitor for multithreaded objects: when debugging,
allows us to print all multithreaded objects' read and write lock
holders.
If an event begins on endpoint A, then calls its partner on endpoint
B, and on B a backout exception gets risen, B will call rollback in
its event parent.  Before this commit, however, because B had not
called a sequence on A, it would not necessarilly forward the backout
back to A.  This commit handles that case.
Using a separate thread to backout from objects in active event.  This
is because: 1) does not violate any correctness guarantees to backout
individually and 2) prevents deadlock.  Can get a case where locked
obj holds lock on obj and then tries to insert iteslf into touched
objs, which acquires _lock on this event.  If, while we are trying to
do this, we call backout (eg., if a backout exception is raised) we
will hold a lock on this event, and then try to lock the object during
backout.  These two together can cause deadlock.  Using a separate
thread instead.