Common base for one-at-a-time 32-bit hashes.

Created a common base class for all the functions that operate on a byte
at a time accumulating a 32-bit hash. That's DJB and FNV now. There
might be more, but even if is just these two, I want to better
accommodate the expression of these hash algorithms.

Currently, they look more like stream algorithms, while the block base
class allows a hash function to be expressed as a blocks and remainders
in a closure. It reads more like an illustrative presentation of the
algorithm. It is mostly algorithm, the only object-orientation overhead
being the split of the algorithm into a blocks function and a remainder
function, but that's a natural split.

I wanted to create a base class for DJB and FNV that would allow for the
basic expression of the algorithms, a loop that updates a hash. I wanted
to get rid of the object housekeeping, and the stream finalization. I
like how the block base class allows for the algorithm to be expressed
in one enclosing function. I didn't like how DJB and FNV look like
stream classes and not hash algorithms.

Now DJB and FNV are expressed entirely in their constructors. They look
like sample code in a blog entry, except they're also production ready
implementations of the entire `crypto.Hash` API.

Closes #23.