Implement 32-bit Murmur3.

Had to implement a 32-bit multiplication method. I'm leaving it in place
for now, but ideally I'd like to inline all the multiplications. I
imagine I might express the math in comments, then us Esprima to compile
the source based on the comments. A line comment is a line of bitwise
operations. The Esprima based utility would parse the comment and then
add the appropriate bit shifting.

Even easier than expressing the math in JavaScript would be to express
it as functions. Run a utility to convert the functions into expanded
math with the function as comments, then run a utility to turn it back
into the functions for debugging.

If I do this for 32-bit, then I might as well go ahead and do it for
64-bit. That way there is no need for an external dependency. The
operations needed to implement the hashes are few, most of the
JavaScript bitwise operations, rotate left and right, and
multiplication.

Of course, it's probably not that difficult, once the sanity test is
passing, to iterate through the hash algorithm and to expand the
function calls into statements. Given the stability of these algorithms,
that is probably not a bad bet.

It does make me wonder though, about the utility of the sanity test. It
could well be the case that, for a bad hash algorithm, one of the lesser
hash algorithms we'll offer, that there is a collision. It makes we want
to test against each step in the sanity test, not just the end result.

It would be a day long project to build a utility using SMHasher to
export the sanity results for each sub-hash in the sanity test.

Maybe I make a project of creating binary equivalents for Node.js?

Closes #16.