Allow ractors to be used within a fiber scheduler context. Currently,
only Ractor.new { ... }.value or Ractor.new { ... }.join are supported
and tested.

When calling Ractor#join or Ractor#value within a non-blocking fiber
scheduler context, do not block the calling thread. Instead, call the
fiber scheduler's `block` method, which will transfer to another fiber
if coded correctly. When the ractor has terminated and is ready to give
its value to the calling thread, it will send an interrupt to that
thread telling it to switch back to its original fiber. If the thread is
blocked on IO (because it's in the fiber scheduler close hook), it will unblock
it by calling its unblock function. When the thread receives the interrupt,
it will call the fiber scheduler's `unblock` method, which will either
transfer to the original fiber or put it on a ready list, if coded correctly.

Ex:

```ruby
scheduler = Scheduler.new # your fiber scheduler
Fiber.set_scheduler scheduler
class << scheduler
  attr_reader :test_blockers
  def block(blocker, timeout=nil)
    (@test_blockers ||= []) << [blocker, timeout]
    super
  end
end
ordering = []
blocked_thread = nil
Fiber.schedule do
  # in f2
  r = Ractor.new do
    # in f3
    sleep 0.5
  end
  ordering << "f2 before join"
  # Calling `r.join` should schedule us away from f2 back to f1. In f1, we end the script
  # and then Scheduler#close is called, which can block on IO.select or similar. When the ractor
  # is finished, it resumes fiber f2.
  blocked_thread = Thread.current
  r.join
  ordering << "f2 after join"
end
ordering << "f1 thread finish"
expected_ordering = ["f2 before join", "f1 thread finish", "f2 after join"]

assert_equal expected_ordering, ordering
assert_equal 1, scheduler.test_blockers.size
assert scheduler.test_blockers.first[0].is_a?(Thread) # the blocked thread that called join
assert_equal blocked_thread, scheduler.test_blockers.first[0]
```

We need to always clear the `waiter` off the current ractor's waiters
list even if we get an uncaught error during the execution of the transferred
fiber. Therefore, we need to be able to delete the `struct ractor_waiter` off
the list multiple times if necessary: once when woken up (if it was woken up) and
also before raising in the waiting thread. We use `ccan_list_del_init` to clear the
node's `next` and `prev` pointers for safe deletion multiple times.

Also, we now RACTOR_LOCK around this list deletion in the case of an error.