Don't use "ready to throw" utility methods

The Ruby.newBlahError methods are expected to return a fully-
prepared RaiseException with stack trace and current $! set. If
these methods are used to create a RubyException for throwing on
another thread, the current thread's stack trace and $! will be
used incorrectly.

Instead, I start the process of adding direct constructors for
Ruby exceptions, starting with RubyIOError.newIOError, which will
return just the Ruby exception object without any preparation for
throwing.

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

@@ -50,4 +50,8 @@ static RubyClass define(Ruby runtime, RubyClass exceptionClass) {
     protected RaiseException constructThrowable(String message) {
         return new IOError(message, this);
     }
+
+    public static RubyIOError newIOError(Ruby runtime, String message) {
+        return ((RubyIOError) runtime.getIOError().newInstance(runtime.getCurrentContext(), RubyString.newString(runtime, message)));
+    }
 }

core/src/main/java/org/jruby/util/io/OpenFile.java

@@ -33,6 +33,7 @@
 import org.jruby.RubyException;
 import org.jruby.RubyFixnum;
 import org.jruby.RubyIO;
+import org.jruby.RubyIOError;
 import org.jruby.RubyNumeric;
 import org.jruby.FiberScheduler;
 import org.jruby.RubyString;
@@ -1353,7 +1354,7 @@ private ChannelFD preRead(ThreadContext context, OpenFile fptr) {
 
             // We should not get here without previously checking, so this must have been closed by another thread
             if (fd == null) {
-                throw newInterruptedException(context.runtime);
+                throw newInterruptedException(context.runtime).toThrowable();
             }
 
             assert fptr.lockedByMe();
@@ -2904,14 +2905,14 @@ public void interruptBlockingThreads(ThreadContext context) {
                 if (thread == context.getThread()) continue;
 
                 // raise will also wake the thread from selection
-                RubyException exception = newInterruptedException(runtime).getException();
+                RubyException exception = newInterruptedException(runtime);
                 thread.raise(exception);
             }
         }
     }
 
-    static RaiseException newInterruptedException(Ruby runtime) {
-        return runtime.newIOError("stream closed in another thread");
+    static RubyIOError newInterruptedException(Ruby runtime) {
+        return RubyIOError.newIOError(runtime, "stream closed in another thread");
     }
 
     /**