The motivation behind this patch is to replace `arrayvec` by `smallvec`.
Why? Because `arrayvec` cannot grow, it's an array-baked vector. Once
the full capacity is reached, it cannot grow any more. That was fine
up until now because it was only used by the `Limit` stream adapter
which needs only 2 values in a buffer that is typed by an `ArrayVec`.
But for other stream adapters, it's a limitation. What if a stream
adapter needs a buffer of more than 2 values?

Ideally, we want to preserve the stack-allocated property for obvious
performance reasons (cache locality, reducing allocator traffic and so
on). However, we also want to be able to fallback to the heap for larger
allocations.

`smallvec` provides this feature. Hence, it does what `arrayvec` does,
with the addition of heap-allocated fallback when it's needed.

This type alias is renamed to `VectorDiffContainerStreamBuffer`.

`Sort` is `VectorDiff` stream adapter that presents a sorted view of the
underlying `ObservableVector` items.

```rust
use eyeball_im::{ObservableVector, VectorDiff};
use eyeball_im_util::vector::VectorObserverExt;
use imbl::vector;
use std::cmp::Ordering;
use stream_assert::{assert_closed, assert_next_eq, assert_pending};

// A comparison function that is used to sort our
// `ObservableVector` values.
fn cmp<T>(left: &T, right: &T) -> Ordering
where
    T: Ord,
{
    left.cmp(right)
}

// Our vector.
let mut ob = ObservableVector::<char>::new();
let (values, mut sub) = ob.subscribe().sort(cmp);
//                                          ^^^
//                                          | our comparison function

assert!(values.is_empty());
assert_pending!(sub);

// Append multiple unsorted values.
ob.append(vector!['d', 'b', 'e']);
// We get a `VectorDiff::Append` with sorted values!
assert_next_eq!(sub, VectorDiff::Append { values: vector!['b', 'd', 'e'] });

// Let's recap what we have. `ob` is our `ObservableVector`,
// `sub` is the “sorted view”/“sorted stream” of `ob`:
// | `ob`  | d b e |
// | `sub` | b d e |

// Append other multiple values.
ob.append(vector!['f', 'g', 'a', 'c']);
// We get three `VectorDiff`s!
assert_next_eq!(sub, VectorDiff::PushFront { value: 'a' });
assert_next_eq!(sub, VectorDiff::Insert { index: 2, value: 'c' });
assert_next_eq!(sub, VectorDiff::Append { values: vector!['f', 'g'] });

// Let's recap what we have:
// | `ob`  | d b e f g a c |
// | `sub` | a b c d e f g |
//           ^   ^     ^^^
//           |   |     |
//           |   |     with `VectorDiff::Append { .. }`
//           |   with `VectorDiff::Insert { index: 2, .. }`
//           with `VectorDiff::PushFront { .. }`

// Technically, `Sort` emits `VectorDiff` that mimics a sorted `Vector`.

drop(ob);
assert_closed!(sub);
```

This patch uses a binary search when the position of a value must be
found. Finding a new value based on the `compare` function can be
costly, hence the use of a binary search.