Radix sort (LSD) and counting sort
I found a list a few things that you could improve, but nothing that would significantly change the way your sorts work:


At the end of the counting sort, you could use std::move instead of std::copy to move the elements to the original collection. For simple integers, it shouldn't change anything but it could make a significant difference if you try to sort big integers.
There is a more idiomatic way to compute sizeof(typename Iter::value_type)*CHAR_BIT in the standard library thanks to std::numeric_limits::digits, so you can actually rewrite rdx_sort as follows:

template &lt;typename Iter&gt;   // range of input not known, just use max ex. 32 bits for ints
void rdx_sort(Iter begin, Iter end) {
    int bits {std::numeric_limits&lt;typename Iter::value_type&gt;::digits};
    rdx_sort(begin, end, bits);
}


Any number library (like a big number library) is allowed to specialize std::numeric_limits and every decent numbers library does so, so I shouldn't make your code less portable. By the way, the returned value is not always int, so the best thing you could do is to use a type alias to make things clearer:

template &lt;typename Iter&gt;   // range of input not known, just use max ex. 32 bits for ints
void rdx_sort(Iter begin, Iter end) {
    using value_type = typename Iter::value_type
    value_type bits {std::numeric_limits&lt;value_type&gt;::digits};
    rdx_sort(begin, end, bits);
}

Be careful of wild assumptions:

const long long mask; // 0..63 bitfield to test against


long long is not guaranteed to be a 64-bit integer, even if it is more often the case than not. If you want to avoid problems, you should use std::int64_t from &lt;cstdint&gt;. This type only exists if the architecture actually has a 64-bit integer, bug I guess that you will have more problems anyway if your implementation does not.

const std::int64_t mask; // 0..63 bitfield to test against

It seems that you are using using namespace std;, which is something you should really avoid in a header-only library like yours. Using this directive will import every name from std:: into the global namespace for anyone using your library and you will for sure end with name clashes at some point. Consider std::-qualifying everything from the C and C++ standard libraries (except macros of course), even std::size_t: some implementations don't import the names from the C standard library into the global namespace.
Dropping random vowels from function names isn't going to help anymore. Consider using full names like counting_sort and radix_sort instead.