Provides the trait CountingSort with a blanket implementation for
Iterators
for all types T that implement (beyond other std or core traits) the here defined
TryIntoIndex trait.
Types that implement this trait can be tried to be converted to an
usize, i.e. an index.

The counting sort algorithm has an O(n+d) (d being the range between the minimum value and the maximum value) asymptotic runtime in comparison to an O(n*log(n))
of the Rust std library implementation of slice.sort

However the memory consumption is higher

Dependent on the range d between the minumum value and the maximum value (d = max_value - min_value),
a Vec of
usize's is allocated

This may fast result in GB of memory: the maximum range of u32 is
4294967295, if usize is 4 bytes, than the memory consumption is 17179869180 bytes or approximately 16 GB
(1 GB = 102410241024 bytes)

Additionally the current implementation does not consume the given iterator

This means the counting sort algorithm excels whenever there are a lot of elements to be sorted but the range
range between minumum value and maximum value is small

counting sort for e.g. HashSet's is sub-optimal since every element exists only
once in a HashSet. Counting sort excels when a lot of elements exist in the
collection but the number of distinct elements is small.

Caution: Be careful using this algorithm when the range between minumum value and maximum value is large

An excellent illustration about the counting sort algorithm can be found here