Simplify class tree of RedisField

Now that all the fields are indexable, move the index stuff in RedisField, with only a MultiValuesField for list, set and sorted set.
Rewrote _traverse_command in MultiValuesField

Previously the helpers defined in _commands_to_proxy were called by _traverse_command, did some stuff and then called _traverse_command , using a "bypass_proxy" argument to not loop indefinitely.

The aim was to provide to arguments, _to_deindex and _to_index, to specify what values to deindex and index.

Now these helpers simply returns some parameters used by _traverse_command:
- the eventually updated args and kwargs passed to _traverse_command
- a dict with:
  - "to_deindex", the list of values to deindex
  - "to_index", the list of values to index
  - "pre_callback", a callback to run before the deindexation (takes args and kwargs, and returns them, actually not used)
  - "post_callback", a callback done before the reindexation, actually used to reindex specific values depending of the result of the command
Move all _traverse_command logic to RedisField

We now have only one place to manage values to index/deindex
and pre/post callbacks

Also correct "collback" to "callback"
Centralize utf-8 handling for index keys
Remove unused temp code commited by error
Pep8 + docstrings in limpyd/fields.py
Add proxy for indexing set/getset and hset

As we know the final value for these three simple commands, we can avoid
getting the field's value from redis before indexing.
Split available modifiers in full and partials

And now commands are all in a _commands attribute of the class:

_commands['all']: available commands
_commands['getters']: commands used to retrieve data from Redis
_commands['modifiers']: commands used to modify data in Redis
_commands['full_modifiers']: commands used to modify data in Redis with defined final value
_commands['partial_modifiers']: commands used to modify data in Redis, without knowing the final value.

The only entries that must be defined are 'getters', 'full_modifiers' and 'partial_modifiers'.
The others are computed based on these three ones.

We slit full modifiers and partial modifiers to handle differently the "transaction" for indexed fields.
Do big operations inside a lock

When a field is updated and needs deindexing/indexing, we run all the
needed operations inside a redis lock.
All the field is locked for writting, for all instances. Only the current
thread can do many operations on it.
The aim of this is to avoid collisions while updating indexes of a
field.
Update commands count in tests with locks.
Add a way to disable locking

If in some case a user doesn't want to use our locking feature that try
to avoid collisions while updating indexes, it's now possible:

- when declaring the model class, by setting the `lockable` attribute to
  False (True by default)
- when declaring the field on the mode class, by setting the `lockable`
  attribute to False (True by default, but already set to False if it's
  False on the model)

If a field is not lockable, the whole stuff (deindexing + call of the
command + indexing) is done without protection, si be careful.

By the way, it's okay to not use locking if you kwow you have only one
thread, to speed up your programs (a lock is 3 redis calls)
List of models must be on the database itself

Before this commit, the list of models was stored on the class, so it wasn't
possible to create many models with the same name on many databases...
Prefix internal params for _traverse_command

Now we prefix the following parameters with an underscore: to_deindex,
to_index, pre_callback and post_callback.

It's to indicate users that they are for internal use only.
Correct a bug when saving locked fields

Before these commits, the _fields_locked_by_self attribute of a class
was shared between all subclasses...
Now each class has its very own one.
First tests for locking
Make lock stuff threadsafe

To allow many operations during a single "command", which may include
deindexing and indexing, we store a flag if the field is currently locked or
not, to bypass lock for other operations within the main lock.

Before this commit, the flags where saved on each RedisModel, at the class
level.
But it was not threadsafe at all, a new thread could have bypassed the lock
because of this.

Now the flags are saved in threading.local
Simple update of index/deindex methods

Now index and deindex methods always iter on a list of values to index/deindex,
even for simple-value fields.

It allows the behaviour already existing in MultiValuesField:
- if the "values" argument is None, get all the values from the field for
  (de)indexing
- if the "values" argument is a empty list, iter on it, but as it's empty,
  do not (de)index anything

Without this commit, it wasn't possible to make the distinction between the two
in simple fields.
Deleting fields now use real _traverse_command

With this we can handle (de)indexing in a single place, always the same way,
and with lock if needed.
Make FieldLock work with fields without instances
Let FieldLock handle the `lockable` attribute

So now we can call FieldLock without having to check if a field is
lockable or not. If not, FieldLock won't lock anything.