This patch adds the `EventsOrigin::Pagination` variant. It does nothing
more than that. This variant is going to be used in the following
patches.

This patch adds the `RoomEvents::chunks_updates_as_vector` field,
and the `updates_as_vector_diffs` method. Let's use
`linked_chunk::AsVector` inside `EventCache`.

This patch implements `Add` for `HandleManyEventsResult` so that it's
easier to accumulate many of them.

…<VectorDiff<_>>`.

The type of `RoomEventCacheUpdate::AddTimelineEvents::events` is updated
from `Vec<SyncTimelineEvent>` to `Vec<VectorDiff<SyncTimelineEvent>>`.
So far, only `VectorDiff::Append` is supported, but more will come in
the next patches.

A new `TimelineInner::add_events_with_diffs` method is added.
It's pretty similar to `add_events_at`, except that it receives
`VectorDiff`s.

…ept an iterator of events.

This patch updates `TimelineInnerStateTransaction::add_remote_events_at`
to accept a generic parameter for `events`, it must implement
`IntoIterator::Item: Into<SyncTimelineEvent>`. At an upper level,
`TimelineStateInner::add_events_at` at the same constraint except
`IntoIterator::IntoIter: ExactSizeIterator>`.

This modification propagates up to `TimelineInner::add_remote_events_at`
and `TimelineInner::add_events_with_diffs`. It removes the need to clone
the `VectorDiff` values which are inside a `Vector` to get a `Vec`.
Basically, it saves memory and computations!

This patch renames `TimelineEnd` into `TimelineNewItemPosition` for
2 reasons:

1. In the following patch, we will introduce a new variant to insert at
   a specific index, so the suffix `End` would no longer make sense.

2. It's exactly like `TimelineItemPosition` except that it's used
   only and strictly only to add **new** items, which is why we can't use
   `TimelineItemPosition` because it contains the `Update` variant. This
   renaming reflects it's only about **new** items.

This patch updates `TimelineItemPosition::Update` from a tuple to a
struct with an `index`, i.e. from `Update(usize)` to `Update { index:
usize }`, for the sake of consistency with the other variants.

This patch adds the `TimelineItemPosition::At` variant that allows to
insert an event at any position.

…em index.

This patch tries to clear confusion between event index and timeline
item index in `TimelineItemPosition`.

…date_event`.

This patch applies event duplication detection in
`TimelineInnerState::add_or_update_event` when the the position is
`TimelineItemPosition::At`.

This patch tries to unify the code to insert timeline item at position
`Start` and `End` (plus `At`, but with a `todo` for the moment). We can
clearly have the same code for these `TimelineItemPosition`s. It doesn't
make sense to have separate implementations, especially knowing that
`End` had duplicated events check while `Start` had not.

This code only and strictly code moving, modulo the `position` handling,
but nothing has changed apart from that.

…rDiff`.

This patch updates `TimelineInner::add_events_with_diffs` to
support more `VectorDiff` variant, notably `Insert` which uses
`TimelineNewItemPosition::At`.

…CacheUpdate`!

Prior to this patch, when the `Timeline` was doing a pagination, the
new events were inside the `EventCache` and also added directly onto
the timeline. However, we already have a mechanism to receive new events
in the `Timeline`, and it's a task run by the `Timeline` builder. New
events are received via `RoomEventCacheUpdate`. The problem is: we have
two entry points to add events: one with `RoomEventCacheUpdate`, and one
with paginations.

This patch removes the second entry point! Now the `Timeline` receives
**all** its events via `RoomEventCacheUpdate`.

This patch updates all the appropriate tests accordingly.

This patch inlines the `Add` implementation for `HandleManyEventsResult`
since it's used only once.

…nction.

This patch is a refactoring. It moves the code block responsible to
handle the `RoomEventCacheUpdate`s into its own function for the sake
of clarity.