Add ExecutionPolicy to SubtypeEffectHandler

This PR introduces the parameter executionPolicy: ExecutionPolicy too all builder functions in CoroutinesSubtypeEffectHandlerBuilder.

ExecutionPolicy gives users simple policies to control concurrency while processing effects for each effect type in the builder. The current implemented policies are:

RunSequentially: all effects of the same type wait for the previous one to finish before executing.
RunConcurrently: all effects of the same type are executed immediately and concurrently.
CancelPrevious: a new effect of the same type start executing immediately and cancel the execution of any previously running effect.

Here is an example of usage:

    Mobius.loop(
            Update(...),
            MobiusCoroutines.subtypeEffectHandler<Effect, Event>()
              .addAction<Effect.Log>(executionPolicy = RunConcurrently) { ... }
              .addConsumer<Effect.UpdateSearchQuery>(executionPolicy = CancelPrevious){ effect -> ... }
              .addFunction<Effect.AddToBag>(executionPolicy = RunSequentially) { effect -> event }
             .build()
    )

By default all functions use RunSequentially. This was selected to avoid unintended cancellations or concurrent problems while processing an effect.

To support this feature the signature of the method addEffectHandler(kClass: KClass<out F>, function: suspend (F) -> Flow<E>) was changed to addEffectHandler(kClass: KClass<out F>, effectHandler: EffectHandler<F, E>). This is non backwards compatible. I'm assuming this is ok, since the method addFlowProducer, or addFlow (introduced in this PR) are analogous and easier to use.

Additionally the function addEffectHandler(kClass: KClass<out F>, effectHandler: EffectHandler<F, E>) allows the user to implement its own concurrency policy by handling the effect & event channels directly in case it needs more fine grained control.

This PR also introduces an utility function MobiusCoroutines.effectHandler( coroutineContext: CoroutineContext, onEffect: suspend (effect: F, eventConsumer: Consumer<E>) -> Unit) which creates a simple effect handler that will run all effects concurrently.

Here is an example of usage:

      Mobius.loop(
            Update(...),
            MobiusCoroutines.effectHandler<Effect, Event>(){ effect, eventConsumer ->
                when(effect) {
                    is Effect.Log -> { ... }
                    is Effect.AddToBag -> {
                        ...
                        eventConsumer.accept(Event.AddToBagSuccess)
                    }
                }
            }
    )

spotify / mobius

Add ExecutionPolicy to SubtypeEffectHandler #176