Fixes & updates

## Updates
* allowed `elliptics.Id` to be initialized by any iterable object and group
* replaced `cPickle` by `msgpack` for packing intermediate results in recovery - it speeded up merging phase
* added new recovery statistics:
  * `total_keys` - total number of keys that will be recovered / processed - available only at `dc` mode
  * `recovery_speed` - average speed of recovering which is measured in keys per second
  * `iteration_speed` - average speed of iteration which is also measured in keys per second
* added ability to iterate keys without metadata (user_flags and timestamp):
  * added `-M` option to `dnet_recovery` which speedups iteration phases of recovery but sacrifices checking metadata. Recovery with this option will not check metadata, will not replace old records by new ones, but will only copy some available replica of keys to groups which do not have these keys.

## Fixes
* fixed `elapsed_time` of async_result calculation and provided start/stop timestamps of async_result
* fixed `PyEval_InitThreads` at `gil_guard()` - some times it crashes python on trusty
* fixed parsing `group` from config - negative group is improper

## Tests
* disabled srw in the cluster for test_specific_cases
* added tests of iteration
* updated tests of recovery: made some cases to use new option `-M`

## Others
* cleaned up python scripts
* moved server fixture to conftest and made server (elliptics testing cluster) session-wide - made pytests to control lifetime of all server nodes 

Do not bring strong typing to python. Basic typing for python is duck typing. This is not the same as `void *`, because `void *` carries no information other than address. `object` allows to check if the object has required properties, methods, fields etc.

Don't repeat yourself: providing such `key_from_*` methods makes you and your users write the same code for different types of object and makes them keep in mind types of all objects they use. And what will they do if they get object with unknown type from somewhere? Which methods should they call for such objects? Is it really necessary to know what is the type of object?

Python way is providing one `key()` method which internally can deal with different, maybe unknown, types and raise exception if type is not satisfied requirements.

Exception in python is not the same as sigfault or what you mean under explosion? What the different between putting some obscure object into `key()` and `into your key_from_*()` methods? Both of them will rise an exception. In the first case you will get 'type of your object doesn't have required properties', in the second you will get 'your object isn't list'. How does this help you?