The easy default implementation would be (and was the first approach) to have a
solid value in cold observable and when anyone subscribes, Cold Observable emits
values to all its subscribers.

That is wrong because e.g. Observer1 subscribing would trigger emitting values
to other observables, that's bad.

The second implementation was that cold Observable contains a solid value and
provides a "getValue" closure. Then e.g. Observer2 subscribing will cause
MapObservable to "fetch" that value from ColdObservable, pump it through its own
transformation function and emit it to Observer2. Side-steps the entire pipeline
and works nicely.

Until you realize that cold Observable shouldn't contain a single hard-coded
value and should be capable of emitting arbitrary amounts of values in
arbitrarily complex constellations (maybe you only emit if a given runtime
config is set) and that's only possible if instead of storing a value you store
a callback function that takes an observer and emits to it.

The problem just becomes if that's the base requirement, how does MapObservable
(which is connected to Observable2 via a "pseudo"-subscription) fetch values
only for Observer2 when Observer2 subscribes?
Because I can't trigger the normal pipeline that would cause ColdObservable to
emit events normally to MapObservable, because that would trigger MapObservable
also emitting values to Observer3 which is not desired.