Found a source of deadlock and removed it.

Source of deadlock:

Consider thread 1:
An AtomicActiveEvent, A, is going through the second phase of its
commit in second_phase_commit, and calls complete_commit_local while
holding its own lock. complete_commit_local calls the complete_commit
method for an AtomicObject. In doing so, it attempts to acquire the
lock for that AtomicObject.

Thread 1 holds A's lock and is trying to acquire the AtomicObject's
lock.

Consider thread 2:
A different AtomicActiveEvent, B, tries to acquire the AtomicObject's
write lock. It acquires the object's internal lock. Then, it checks to
see if it can preempt the other events that are currently holding its
read and write lock. It does so by calling into the object's
can_backout_and_hold_lock method, which tries to acquire a lock on A.

Thread 2 holds the internal lock of the AtomicObject and is trying to
acquire A's lock.

These two threads combine to potentially create deadlock. Must fix.

-----------------
Fixed by recognizing that complete_commit_local doesn't actually need
to happen within an AtomicActiveEvent's lock: by the time we get to
it, its touched_objs map cannot change and individual objects will not
be able to back the event out because it has already changed its state.

Note: this commit removed ability to exec signal functions at end of
an event.  Next commits will remove signals completely.
Deprecated atomic events' having signals.