Drop task-completion transfer; rely on Fiber.blocking only.

The unconditional Fiber.scheduler&.transfer at task completion left task
fibers parked (alive but finished) instead of terminating, which breaks
Fiber#alive? assumptions in io-event (timers/waiters transfer into
finished fibers) and caused downstream servers to hang.

The Fiber.blocking change alone fixes the reported cases (Enumerator,
bare Fiber.new) since those enter the reactor fiber via resume, so task
termination returns control correctly. The transfer-based-scheduler case
requires the Ruby-level fix in https://bugs.ruby-lang.org/issues/20081
and is not addressed here.

Also fix RuboCop block delimiter spacing in tests.

Assisted-By: devx/5f4cfab6-1d74-4100-8755-82d7c62c70ab

Author: samuel-williams-shopify

lib/async/task.rb

@@ -532,11 +532,6 @@ def schedule(&block)
 					# Console.info(self) {"Task ensure $! = #{$!} with #{@children&.size.inspect} children!"}
 					finish!
 				end
-				
-				# Transfer control back to the scheduler (which may not be the root
-				# fiber). This is skipped when a critical exception propagates out of
-				# the block above, so that it is not swallowed by the transfer.
-				Fiber.scheduler&.transfer
 			end
 
 			@fiber.async_task = self

releases.md

@@ -3,7 +3,6 @@
 ## v2.42.0
 
   - `Sync` and `Async` can now be invoked from a non-blocking fiber that has no scheduler (e.g. inside an `Enumerator` or a bare `Fiber.new`). Previously this raised `RuntimeError: Running scheduler on non-blocking fiber!`. The reactor is now run within `Fiber.blocking`, so the scheduler always runs on a blocking fiber.
-  - When a task finishes, it now explicitly transfers control back to the scheduler (`Fiber.scheduler&.transfer`). This ensures the event loop regains control even when it is running on a fiber that is not the thread's root fiber (e.g. a fiber owned by another transfer-based scheduler), rather than relying on fiber termination returning control to the correct fiber.
 
 ## v2.41.0
 

test/kernel/sync.rb

@@ -59,7 +59,7 @@
 
 			it "returns the result of the block" do
 				result = Fiber.new do
-					Sync{|task| value}
+					Sync {|task| value}
 				end.resume
 
 				expect(result).to be == value
@@ -98,7 +98,7 @@
 				Fiber[:annotation] = "outer"
 
 				result = Fiber.new do
-					Sync{|task| Fiber[:annotation]}
+					Sync {|task| Fiber[:annotation]}
 				end.resume
 
 				expect(result).to be == "outer"
@@ -131,49 +131,13 @@
 			it "cannot yield to the enumerator from within the block" do
 				# Yielding to the enumerator's consumer from inside `Sync` happens on the task fiber, which is not resumable, so it fails cleanly rather than hanging:
 				enumerator = Enumerator.new do |yielder|
-					Sync{yielder << value}
+					Sync {yielder << value}
 				end
 
 				expect do
 					enumerator.next
 				end.to raise_exception(FiberError)
 			end
-			
-			it "returns control to the scheduler when the loop fiber is entered via transfer" do
-				# The reactor loop fiber may be entered via `Fiber#transfer` (e.g. owned
-				# by another transfer-based scheduler), which places it off the resume
-				# chain. When a task terminates, control must return to the loop fiber so
-				# the reactor can finish - not to the resume-chain root. Without this,
-				# the reactor is abandoned and the scenario deadlocks, so we run it in a
-				# separate thread with a timeout:
-				completed = nil
-				
-				thread = Thread.new do
-					driver = worker = nil
-					
-					worker = Fiber.new do
-						completed = Sync do |task|
-							task.async{sleep(0.001)}.wait
-							value
-						end
-						
-						driver.transfer
-					end
-					
-					driver = Fiber.new do
-						# Enter the loop fiber via transfer, so it is off the resume chain:
-						worker.transfer
-					end
-					
-					driver.resume
-				end
-				
-				finished = thread.join(2)
-				thread.kill unless finished
-				
-				expect(finished).not.to be_nil
-				expect(completed).to be == value
-			end
 		end
 
 		it "cannot be worked around by running the scheduler on a nested blocking fiber" do