adding cast votes to `oneCandidate`s and efficiency changes

The thought has occured to Me to have a stage of IEVS where all
of the Voters' information about Candidates is transfered to the
`oneCandidate` objects. The benefit of this approach would be
two-fold:
	1. reduced need for looping thru Each Voter for Each
	   Candidate, such as in the case of `TopMedianRank()`
	2. consistency with the notion of Voters casting (or
	   "giving") various sorts of votes to Candidates

The question, however, is how to approach the problem. One
approach would be:
	1. create `std::vector<std::reference_wrapper<const SomeType>>`
	   objects
	2. reserve `MaxNumVoters` for each such object
	3. every time the information needs to be transfered
	   from Voters to Candidates, `clear()` the objects and
	   `push_back()` referents

An alternative approach would be to copy by value instead by
reference, allowing the use of `std::valarray<SomeType>` objects
instead. (Could the `SomeType` be `const SomeType`? Not with
`std::valarray<>`, no.) Performance testing is required to
determine which approach is faster.

Performance testing reveals the `std::valarray<SomeType>`
approach is anywhere from 13% to 39% faster than the
`std::vector<>` approach.

While making this change for `TopMedianRating()`, there is the
additional question of how best to identify the median value of
such votes for functions like `TopMedianRating()`. Currently,
the program uses an implementation of the Floyd-Rivest
algorithm. However, 100 thousand tests later and the approach I
think We should take is to use `std::nth_element()` to find the
median (or one of the bi-medians) and either multiply the result
by `2`, if the number of elements is odd, or, if the number of
elements is even, add the maximum of all elements between
element `0` and this bi-median, not including said bi-median.
This approach appears to be fastest on average according to the
100 thousand tests, even if not always.