Compile-time string hash
Your code looks very clean to me and I already like it very much. A few minor remarks.


Assuming that you'll probably want to provide this functionality in a header file, you should declare all your functions as inline. Even if they're not in a header file, it doesn't hurt to do so.
Consider declaring your functions as noexcept, too.
I'd prefer to see the implementation details hidden in a “detail” namespace to make it clear that only hashCString is supposed to be used directly. (Or is this assumption incorrect?)
ct::hashCString is not the most descriptive name. I'd prefer if the name somehow indicated the implemented hash algorithm.
You don't actually need the length of the string. Just replace length != 0 with *cstr != '\0' in hashImpl and figure out the length as you go. This will save you one function.
It seems to me that “plus” or “add” would be more consistent with “xor” than “sum” as the emphasis is on the operation.
Your code assumes that char is an 8 bit integer. It would also be nice if you could hash arrays of signed and unsigned chars alike. Something like the following might do.

template &lt;typename CharT&gt;
constexpr typename std::enable_if&lt;std::is_integral&lt;CharT&gt;::value &amp;&amp; (CHAR_BIT * sizeof(CharT) == 8), std::uint8_t&gt;::type
hashCString(const CharT *const s) noexcept;


Instead of requiring CHAR_BIT * sizeof(CharT) == 8, you could relax it to (CHAR_BIT * sizeof(CharT)) % 8 == 0 and manually loop over each octet in wider types. Smells like overkill, though.
Another possible generalization would be to provide the classical interface that takes a pair of “begin” and “end” iterators. This might be handy for hashing sub-strings, strings with embedded zeros or strings that are not terminated with a 0 byte. You can still provide your single-argument version as a convenience overload.