Support for minimal ViewModel churn

[JakenVeina]

I have the following scenario, for building an ObservableCollection<T> of ViewModel objects:

• Each ViewModel is self-updating, I.E., monitors the state of a single record, identified by ID, and publishes changes in that record's state.
• Each ViewModel is interactive, I.E. supports a variety of user actions to edit that record, and submit those edits to the data source, along with validation logic.

In particular, it's the "interactive" nature of each ViewModel that makes them relatively expensive to construct, due to the number of data streams and commands that need to be constructed. Plus, swapping out an entire ViewModel within the binding layer is much more expensive than just having a bound property publish a new change. As such, my goals are:

• To only construct one ViewModel for each record, I.E. when new records are added.
• To only remove ViewModels when their record is removed.
• To move ViewModels within the collection, when a change in the record affects the sort order.
• To have all other updates in the UI handled by the ViewModel itself.

By my reckoning (which may well be wrong) this is not achievable with DynamicData, for the following reasons:

• .Transform() does not preserve sorting information upon a sorted stream, as it only supports streams of IChangeSet<> rather than ISortedChangeSet<>
• There isn't any operator to ignore Update changes, but still preserve Move changes.

I was able to build a proof-of-concept to solve these two issues, and build the following stream/query that behaves exactly as I want.

using var viewModelsBinding = resources.Connect()
    .Sort(SortExpressionComparer<ResourceEntity>
        .Ascending(resource => resource.Name)
        .ThenByAscending(resource => resource.Id))
    .Transform(resource => resource.Id)
    .ReduceRedundantChanges()
    .Transform(CreateViewModel)
    .Bind(out var viewModels)
    .Subscribe();

Specifically, I implemented a .Transform() operator that accepts ISortedChangeSet<> and emits ISortedChangeSet<>, preserving all the sorting state info, as well as a .ReduceRedundantChanges() operator that behaves similarly to .IgnoreSameReferenceUpdate() except that it preserves Updates where the value is the same, but the index has changed, and translates those into Moves instead of ignoring them.

Is there a combination of operators that I'm not spotting that would achieve this?

If not, is there any interest in a PR that would add either of these extensions?

[JakenVeina]

Also could use a .DisposeMany(IObservable<ISortedChangeSet<TObject, TKey>>) overload.