Functionally this method is equivalent to the following:

    let mut items = counter.most_common_ordered();
    items.truncate(k);
    items

However, by using a binary heap to keep only the `k` most common items,
the implementation can be more efficient, often much more so,
than sorting all the items.

There is no reason to preserve the relative order of items that compare
equal, since that order is already unspecified due to the hashing used
by the `HashMap`.  The unstable sorting algorithm (quicksort) is
typically faster than the stable sorting algorithm (timsort) and does
not require the temporary storage used by the latter.

Benchmarks comparing `Counter::most_common_ordered()` and
`Counter::k_most_common_ordered(n)`, where `n` is the length of the
counter, found that the heapsort used by `k_most_common_ordered()` was
typically faster than the stable sort used by `most_common_ordered()`.
However, this is no longer the case when switching to the unstable sort;
the quicksort implementation is typically a little faster than the
heapsort, so now it is better for `k_most_common_ordered()` to call
`most_common_ordered()` with `k >= n`.

I hadn't previously used BinaryHeap::peek_mut, and wasn't sure about
its semantics when changing the value, so I wanted to ensure that
we really weren't going to lose any data.

With this test, I am pretty confident in this implementation.