Try to grab `y.index` before returning `np.arange(len(y))`

After discussions with Brian Granger, Fernando Perez Peter Wang, Matthew
Rocklin and Jake VanderPlas this is a proposal for how to deal with
labeled data in matplotlib.

The approach taken is that if the optional kwarg 'data' is passed in any
other string args/kwargs to the function are replaced be the result
`data[k]` if the key exists in `data`, else leave the value as-is.

If white list is provided, only try to replace those.

Not tested or used.

This version uses inspect to get the parameter names of a function
and only needs the list of to-be-replaced argument names. In case
inspect can't get a list of parameter names (e.g. *args is used),
the developer has to supply a the complete list of argument names.

This approach only needs for most cases only the list of
replacements and only in the worst case (*args) a additional list
of the names of all positional parameters and not synced two lists
of position and names.

It also makes some "import/ compile time" checks which should warn
devs when the decorator is used with wrong / insufficient arguments.

This also includes the "guess the label"-feature.

None seems the be used much more often than 'y'

Not done: long lines between 80...100

Test code was auto-reformatted in pycharm with max line length 100

If the input data has a `name` attribute and a label is in explicitly
passed in, use the name as the label that will be used in automatic
calls to `legend`.

Now variable length *args can be named and individually replaced.

This unfortunately does not help for plot() because some abiguity as there
is no way to know in some cases if a users wants to get something replaced or not:

```python
data = {"x":X,"y":Y, "c":C}
plot(x,y,c,x,y,c, data=data)
plot(x,y,x,y,x,y, data=data)
```

Here the first call will get all args replaced and matplotlib would
then see all 6 arrays which would translate into three lines with the
same color information (like the second call). In some cases this can
be catched (like for one/three lines with 'x,y,c' combos -> 3/9 args,
will end up with one "missing" if all are treated as replaceable) but
in some cases it's not possible without guesswork. :-(

But in other settings, where the number of args determines the order/names,
this works.

Also activate the tests for the first time...

In python > 3.2 `functools.update_wrapper` (which backs the `wraps`
decorator) adds `__wrapped__` attribute to the returned function to
provide easy access to the base function.  Mock this up for legacy
versions of python.

pie was a method, which did not work with a data kwarg as it
didn't have a **kwargs catch all which would make pyplot.pie pass
this argument to the decorated function.

Document that the decorated functions are tested in the axes test
cases.

Arbitrary long args, i.e., plot("x","y","r","x2","y2","b") were problematic if
used with a data kwarg and the color spec ("r", "b") was included in data: this
made it impossible in some cases to determine what the user wanted to plot:

plot("x","y","r","x2","y2","b", data={..., "r":..., "b":...)

could be interpreted as

plot(x, y, "r") # all points red
plot(x2, y2, "b") # all points black

or

plot(x,y)
plot(r,x2)
plot(y2,b)

This could lead to hard to debug problems if both styles result in a similar plot
(e.g. if all are values in the same range). Therefore it was decided to remove
this possibility so that the usere gets a proper error message instead:

matplotlib#4829 (comment)

There is still a case of ambiguity (plot("y", "ro", data={"y":..., "ro":...),
which is now detected and a warning is issued. This detection could theoretically
be used to detect the above case as well, but there were so many corner cases,
that the checks became too horrible and I took that out again.

Note that passing in data directly (without a data kwarg) is unaffected, it still
accepts arbitrary long args.

Also make a unit test more specific, as it triggered a warning which
wasn't intended in that case. The warning is tested a few lines later...

IPython ships a version of `Signature` and friends that runs on python
>=2.7.  Fall back to this version of things for python <=3.2.

MNT: use IPython's signature if needed + available

Vetter checks for python and IPython

More fixes

If the second arguement to `plot` is both in data and a valid style code
warn the user.