`withContext` ingnores cancellation from `withTimeout` when the dispatcher cannot execute the body

[zuevmaxim]

Describe the bug

The following code hangs, while I expected it to output Timeout. When I uncomment the commented code, it works as I expected, so withContext handles timeouts differently. I wonder if it can be handled correctly without a deadlock here.

Provide a Reproducer

package kt.coroutines

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.Channel
import java.util.concurrent.Executors
import kotlin.coroutines.resume

fun main() {
    val executor = Executors.newSingleThreadExecutor { r -> Thread(r, "MyThread") }
    val dispatcher = executor.asCoroutineDispatcher()
    runBlocking(dispatcher) {
        runBlocking { // block on the dispatcher thread
            val c = Channel<String>()
            launch(Dispatchers.Default) {
                try {
                    withTimeout(1000) {
//                        suspendCancellableCoroutine { cont ->
//                            executor.submit {
//                                c.trySend("Switched to dispatcher")
//                                cont.resume(Unit)
//                            }
//                        }
                        withContext(dispatcher) { // cannot switch to dispatcher as it is locked, but can it timeout?
                            c.send("Switched to dispatcher")
                        }
                    }
                } catch (_: TimeoutCancellationException) {
                    c.send("Timeout")
                }
            }
            println(c.receive())
        }
    }
    executor.shutdown()
}

version 1.9.0

[dkhalanskyjb]

Simplified reproducer:

runBlocking {
    val perpetuallyBusyDispatcher = object: CoroutineDispatcher() {
        override fun dispatch(context: CoroutineContext, block: Runnable) {
            // do nothing
        }
    }
    coroutineScope {
        launch(perpetuallyBusyDispatcher) {
            error("Unreachable code")
        }
        cancel()
    }
}

hangs.