[MRG] Sparse label_binarizer

This is a continuation of a part of PR #2458 based on the code already written by @rsivapr and @arjoly from the branch https://github.com/arjoly/scikit-learn/tree/sparse-label_binarizer.

The first steps are to write tests to motivate correctness and then implement the appropriate changes in label.py.

Initial Checklist:

- [x] label validation on ```LabelBinarizer()``` - with testing
- [x] label validation on ```label_binarizer()``` - with testing
- [x] Import changes for label.py from arjolys branch sparse-label_binarizer
- [x] Import changes for test_label.py from arjolys branch sparse-label_binarizer
- [x] Handle case where type_of_target gets a sparse matrix input
- [x] Debug: One Label Tests in sklearn/tests/common.py
- [x] Test ```is_label_indicator_matrix``` with sparse input
- [x] Test ```label_binarize``` with binary one class case 
- [x] Break down _inverse_label_binarize

Rebase Checklist:

- [x] Rebase on top of PR #2657 changes in label.py
- [x] Rebase on top of PR #2657 changes utils/multiclass.py
- [x] Reintegrate sparse_output tests in test_label.py
- [x] Reintegrate sparse_output tests in utils/test_multiclass.py
- [x] Reintegrate coverage boosting tests in test_label.py, test_multiclass.py
- [x] Include changes to Misc. files guided by make errors
- [x] Documentation updates
- [x] Deprecate parameters in lable.py as in previous changes

To recap the motivation: Python loops are relatively slow, compared to numpy operations over the same data. Even when given a sparse matrix here, it's much more likely to have n_samples >> n_classes than the other way around, so we should avoid iterating in Python over each sample, which is what `for i, (start, end) in enumerate(zip(y.indptr[:-1], y.indptr[1:])):` does in a CSR.

However, you might need to directly iterate over all samples where there is a mix of negative values and zeroes, because I can't think of a simple vectorized (i.e. fast numpy function) way to do what you need to do: identify the first class that has an implicit zero. You currently do this with `np.setdiff1d` (the "set diff").

This hassle could be avoided by writing the solution in Cython, where loops are all fast, but that might be overkill, especially since we might assume that the "mix of negative values and zeroes" is pretty uncommon.