Encode text to UTF-8 bytes in _PylibMC_RunSetCommandSingle

The _key_normalized_obj function already encodes text strings as UTF-8
bytes, but _PylibMC_RunSetCommandSingle explicitly rejected text strings
in the PyArg_ParseTupleAndKeywords format string. Change the format
string to accept text strings, byte strings and any read-only buffer-
compatible object.

The 's#' format returns a char* instead of a 'bytes' PyObject* though,
so also run it through PyBytes_FromStringAndSize to get something
that can be used as a cache key.
setup.py: use __future__ print_function import

This makes setup.py valid syntax in both Python 2 and 3.
Tests: drop six.PY3 checks now that text strings can be used as keys

Also use the six.moves library for 'range' and 'queue'.
Add UTF-8 encoding test case

Ensure that a text string and its UTF-8 encoding are equivalent keys.
Add Python 3.2 - 3.4 to Travis config
Encode text to UTF-8 bytes in _PylibMC_RunCasCommand

<same description and justification as the change to
_PylibMC_RunSetCommandSingle>
test_zerokey: fix type-mismatched key comparison
Fix types in test_cmemcached

The memcached append and prepend operations require byte string
values, so unconditionally use the 'b' prefix on Python 2 and 3.

This is valid syntax in Python 2.6+, which matches the supported
versions in .travis.yml.
Fix inflation of compressed data

Py_BuildValue("s#", ...) doesn't quite work for this -- this tries to
decode inflated_buf as UTF-8. Explicitly convert into a bytes object
instead.
doctests: only check md5 of byte string values

Text strings have to be encoded before they're hashed. We could
do this, but it suffices to directly check the equality of the values.
Accept text strings as key prefixes

Convert them to byte strings in the same way as keys themselves.
Serialization: fix handling of numeric values and booleans

In Python 2, pylibmc essentially calls str() on the numeric value
and uses this byte string as what's stored in the cache. I didn't see
a very clean way to do this in Python 3, but this approach does work.

This does: numeric value -> text string containing ASCII representation
of the numeric value -> byte string that is the UTF-8 encoding of that
text. Boolean values are serialized the same way, just with a different
flag.
delete_multi: replace PyMapping_Check in Python 3

This returns True for tuples and lists now.
_PylibMC_DoMulti: fix concatenating bytes and str
Update doctests for Python 3

This includes syntax changes (print function), data type changes
(dict.keys() no longer returns a list) and bytes/text differences
(getting the keys directly from memcached always produces byte
strings).