First attempt at plumbing for bytes -> str key mapping

pylibmc encodes `str` keys to UTF-8 before using them in any memcached
call. These keys are of course returned from memcached as byte strings,
and it would be nice to give a `str` back to the user if that's what was
passed to pylibmc.

There seem to be two ways to do this:

1) Each call can track whether the keys were `str` or `bytes`. If `str`,
   all keys would be decoded to text before returning them. An exception
   should be raised if the key types are mixed.
2) Support mixed types by tracking whether each individual key was
   provided as `str` or `bytes`. Return each key using its original
   type. This can be done by iterating over the keys and building a
   `dict` that maps each key's UTF-8 encoding to the original `str`
   object. When processing keys from memcached, try to obtain its
   original `str` from this mapping -- if there's no entry for a key,
   it was provided as `bytes` and should be left unchanged.

The new `_PylibMC_map_str_keys` function iterates over the available
keys, builds the `dict` described in #2 above, and returns a new
reference. (The caller is responsible for calling Py_DECREF.)

This should be usable for all of the "multi" functions defined in
pylibmc. `get_multi` and `delete_multi` take iterables of keys as
arguments, and iterating over the key -> value mapping from `set_multi`
should also produce those keys.
_PylibMC_map_str_keys: fix syntax, variable usage
PylibMC_Client_get_multi: return matching key types
_PylibMC_RunSetCommandMulti: return matching key types
_PylibMC_map_str_keys: don't restrict to Python 3

It's a good idea to return matching types in all versions of Python.
Update doctest for #158 with stricter test
Fix a few tests for new 'matching key types' functionality

Keys from memcached were previously assumed to be byte strings.
Fix more tests (missed pylibmc/__init__.py)
Doctests: work around Python 3.2's lack of the 'u' string prefix
Doctests: don't wrap sorted(...) in list()

It's redundant.
Update Python 3 bytes/str keys documentation
_PylibMC_map_str_keys: always return a valid dict

If something goes horribly wrong and we can't iterate over the keys
provided to one of the "multi" calls, we previously returned NULL for
the key translation mapping. This would then cause a segfault when
we try to use this object later.

Now, just return the valid (but empty) `dict`.
Python 3 bytes/str keys documentation: improve example

Make the behavior a bit clearer by only using two keys, removing the
call to incr_multi, and using more descriptive key names. It's too
easy to miss the `b` string prefix when the key name is also `b`.

Additionally, remove the broken call to sorted():

    >>> sorted(['1', b'2'])
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: unorderable types: bytes() < str()
Fix probable refcount leaks in freeing bytes -> str mapping

PyDict_SetItem does *not* steal references to items that it's given.
Merge pull request #162 from hfalcic/match-key-types

Match key types