Redesign API: merge Block and CostFunction

So we have a pretty big API rewrite here. Hope it will be the first and also the last :-). But I think it's for the best. API is much more flexible now !

`Block` has been removed and block logic is now handled in `CostFunction`.

A short example of the API use:

```python
from sktracker import data
from sktracker.tracker.cost_function.brownian import BrownianLinkCostFunction
from sktracker.tracker.cost_function.diagonal import DiagonalCostFunction
from sktracker.tracker.matrix import CostMatrix

# Get some data to play with

trajs = data.brownian_trajs_df()
times_stamp = trajs.index.get_level_values('t_stamp').unique()

t0 = times_stamp[3]
t1 = times_stamp[4]
pos0 = trajs.ix[t0]
pos1 = trajs.ix[t1]

# Define CostFunction according to the tracking you want to perform
link_cost_func = BrownianLinkCostFunction(parameters={'max_speed': 5.})
birth_cost_func = DiagonalCostFunction(context={'cost': 5**2})
death_cost_func = DiagonalCostFunction(context={'cost': 5**2})

link_cost_func.context['pos_in'] = pos0
link_cost_func.context['pos_out'] = pos1

birth_cost_func.context['objects'] = pos1
death_cost_func.context['objects'] = pos0


cost_matrix_structure = [[link_cost_func.get_block(),  death_cost_func.get_block()],
                         [birth_cost_func.get_block(), None]]

cm = CostMatrix(cost_matrix_structure)

# Solve the CostMatrix
cm.solve()
```

Now a much higer level example:

```python
true_trajs = data.brownian_trajs_df()

solver = ByFrameSolver.for_brownian_motion(true_trajs, max_speed=5)
trajs = solver.track()

# Same API as before -> awesome !
```

---

`CostFunction.get_block()` is called to build matrix block. The internal is very simple. The method call `CostFunction._build()` which actually build the matrix.  `CostFunction.get_block()` is only usefull to perform some matrix structure verifications (for now it does nothing, but it could usefull in the future).

Next big change : context !

All dynamic objects used in  `CostFunction._build()` are stored in ``CostFunction.context` and static objects are stored in `CostFunction.parameters`.

So at the beginning of the `CostFunction._build()` you may want to perform some test before building the block matrix to be sure you have all you need : 

```python
# From BrownianLinkCostFunction class
def _build(self):
    """
    """

    # Get parameters
    coords = self.parameters['coords']
    distance_metric = self.parameters['distance_metric']
    max_speed = self.parameters['max_speed']

    # Check context
    pos_in = self.check_context('pos_in', pd.DataFrame)
    pos_out = self.check_context('pos_out', pd.DataFrame)

    # Chech vectors
    self.check_columns([pos_in, pos_out], list(coords) + ['t'])

    dt = pos_out['t'].iloc[0] - pos_in['t'].iloc[0]

    # Build matrix block
    distances = cdist(pos_in[coords].astype(np.float),
                      pos_out[coords].astype(np.float),
                      metric=distance_metric)

    distances /= np.abs(dt)
    distances[distances > max_speed] = np.nan
    distances = distances ** 2

    return distances
```

Read tests for more examples !