Remove dependency on Dispatchers.Main.immediate for immediate dispatching in Compose.

[colinrtwhite]

Fixes an issue with Coil's public composables where its memory cache check could miss the first frame due to dispatching. This case occurs with Paparazzi/Roborazzi/AndroidX screenshot tests and is due to the dispatcher provided by rememberCoroutineScope() either not supporting immediate dispatching, Dispatchers.Main.immediate being unavailable, or Dispatchers.Main.immediate using a different underlying thread.

To fix this I tried a couple things:

• Using CoroutineStart.UNDISPATCHED with a StateFlow. This works for initial composition, but does not resolve synchronously from the memory cache on subsequent requests (e.g. when the AsyncImage(model) changes).
• Attempting to create a CoroutineDispatcher that re-enables dispatching after the first time the context's CoroutineDispatcher changes. As far as I can tell this isn't possible at the moment with CoroutineInterceptor's hooks.

I settled on using a custom CoroutineDispatcher that acts like Dispatchers.Unconfined until after the CoroutineContext's dispatcher changes. This is safe for Coil's internals as it's all thread safe. Aside from fixing the above issue this has a number of benefits:

• This ensures we have consistent behaviour in all environments instead of falling back to Dispatchers.Unconfined if Dispatchers.Main.immediate is unavailable.
• kotlinx-coroutines-swing no longer needs to be added manually as a dependency on JVM.

[zach-klippenstein]

This is really clever, glad you were able to figure out a solution and even get rid of that swing dep!

[zach-klippenstein]

Took me a while to understand how ForwardingUnconfinedCoroutineScope and ForwardingUnconfinedCoroutineDispatcher interact. Could the code that wires them up with the launch be extracted into a helper function? That logic seems mostly unrelated to the other logic in this function, which is more high-level, and pulling it out might make this a bit more readable.

Eg. (names are arbitrary):

// Observe the latest request and execute any emissions.
rememberJob = scope.launchTemporarilyUnconfined {
  restartSignal.transformLatest<Unit, Nothing> {
    _input.collect { input ->
      withNormalDispatch {
        val previewHandler = previewHandler
        // ...
      }
    }
  }
}

fun CoroutineScope.launchTemporarilyUnconfined(
  block: suspend DeferringDispatchScope.() -> Unit
): Job {
  val originalDispatcher = coroutineContext.dispatcher ?: Dispatchers.Unconfined
  val forwardingScope = ForwardingUnconfinedCoroutineScope(scope.coroutineContext)
  forwardingScope.launch(Dispatchers.Unconfined, CoroutineStart.UNDISPATCHED) {
    DeferringDispatchScope(this, originalDispatcher).block()
  }
}

class DeferringDispatchScope internal constructor(
  scope: CoroutineScope,
  private val originalDispatcher: CoroutineDispatcher
): CoroutineScope by scope {
  // This could also just be a function passed as a normal param to launchDeferringDispatch's
  // block lambda if you don't want to bother with a separate class. 
  suspend fun <T> withNormalDispatch(block: suspend CoroutineScope.() -> T) =
    withContext(ForwardingUnconfinedCoroutineDispatcher(originalDispatcher), block)
}

but that might be a bit over-engineered, just an idea.

[zach-klippenstein]

Consider documenting that after setting this to false, it's ignored even if set to true again.

[zach-klippenstein]

Oo this is a neat trick.