Clear interrupt queue when acting on interrupt

If we don't clear the queue here and begin to act on a kill or
raise event, we may poll again and find a different event that
invalidate the one we're currently propagating. This led to
intermittent failures on this spec:

Thread#report_on_exception= when set to true prints the backtrace even if the thread was killed just after Thread#raise

This spec tests that a raise event propagates all the way out even
if a kill interrupts that process. It is difficult to simulate
that without clearing the queue, since we poll for new interrupts
many places that might be hit while raising (such as when printing
out the report that an exception terminated the thread).

The risk here is that an event will be lost, but it is unclear if
it should be possible to queue multiple events that trigger stack
unrolling.

core/src/main/java/org/jruby/RubyThread.java

@@ -331,16 +331,15 @@ private int getInterrupts() {
     }
 
     private IRubyObject pendingInterruptDeque(ThreadContext context, int timing) {
-        for (Iterator<IRubyObject> iterator = pendingInterruptQueue.iterator(); iterator.hasNext();) {
-            IRubyObject err = iterator.next();
+        for (IRubyObject err = pendingInterruptQueue.peek(); err != null;) {
             int maskTiming = pendingInterruptCheckMask(context, err);
 
             switch (maskTiming) {
                 case INTERRUPT_ON_BLOCKING:
                     if (timing != INTERRUPT_ON_BLOCKING) break;
                 case INTERRUPT_NONE:
                 case INTERRUPT_IMMEDIATE:
-                    iterator.remove();
+                    pendingInterruptQueue.clear();
                     return err;
                 case INTERRUPT_NEVER:
                     break;