Had been using incorrect parent method when rolling back on
endpoints.
With new set of code, active event is responsible for removing event
from active event map.  Should not do so in service action
... otherwise, will lose previous priority.
Ignore the print statements for now.  The big change is that an object
should be able to back out of an event that has already backed out.
_backout_touched_objs acquires a lock on touched_objs.  then for
each of its touched objects, it runs through backing them out
(acquiring a lock on each object).

However, when determining if can preempt a read/write lock holder,
we compare priorities (etc.), but then call
can_backout_and_hold_lock.  This holds the active event's lock.
Following this, the object calls
obj_request_backout_and_release_lock, which acquires a lock on
touched_objs.

Order in first case: lock touched_objs, then lock obj.  Order in
second case: lock obj, then lock touched_objs.

Solution is to make a copy of touched objs while in lock before
iterating over each obj, individually backing them out.  This should
be okay because, after we get to this point in the code, we should
never be adding more objs to touched_objs.
It is important to sort the list of events by uuid before iterating
through them.  This is so that we can prevent deadlock when two
different objects are iterating through their lists.  (Should not use
priorities because they can be stale between objects.)