Commit does 3 things:

   1) Gets rid of a bunch of ugly debug print statements that snuck
      into waldoLockedActiveEvent

   2) Increased the number of events to run in starvation test

   3) MOST IMPORTANTLY: Found cause of assertion errors.  When we
      preempt an event, we hold locks on it and then request it to
      backout.  However, the code for backing out an object would call
      backout on the object itself.  The object's backout method had a
      try_next method at the end of it.  This meant that we could get
      a bug in which we a) cleared a read/write lock holder, b) tried
      next on waiting elements and scheduled a waiting element, and c)
      overwrote the now scheduled waiting element with the event that
      preempted the initial read/write lock holder.  (The overwriting
      didn't pass a message back to the active event that was being
      overwritten, so it might transition into a running state and be
      none the wiser.)  Fixed this by just not calling backout on the
      object from the active event.
Note: Previously, immediately after calling request_and_release_lock
on each obj, we just overwrote write_lock_holders and read_lock
holders.  This is insufficient however because the active event may
also be a waiting element.  Consider the case where we have a read
lock holder that is waiting to become a write lock holder.  If we then
backout of the read lock holder, we should also back out of its
waiting element.  Otherwise, the waiting element will eventually be
scheduled.