Initial work on multiple dispatch for SymPy

Added @dispatch decorator to create multiple dispatched function.

I also rewrote the tensor module to have it work with @dispatch.

Work is still in progress.

TODO list:

* [ ] create `DispatchedBasic` and `DispatchedExpr` objects, which link the operator methods to properly multiple-dispatched functions, e.g. `__add__(self, other) ==> add(self, other)`.
* [x] finish `varargs` (to dispatch elements as `*args`).
* [ ] discuss whether to dispatch `**kwargs`` too (my idea is NO).
* [ ] inspect how @dispatch interacts with docstring generation.
* [ ] inspect how @dispatch interacts with other sympy decorators.
* [ ] find a way to dispatch methods of classes without adding prefixes.
* [ ] dispatch functions with default values: 

```
@dispatch(type1, type2)
def f(a, b=3):
    ...
```

* [ ] should an istance of `DispatchedFunction` subclass python's `function` type?
* [ ] should we test multiple usage of `@dispatch` on the same function? E.g.

```
@dispatch(type1)
@dispatch(type2)
def f(a):
    ...
```
* [ ] test subclasses if dispatcher is kept on classes.
* [ ] check dispatched methods and RST documentation generation.
* [ ] test dispatching on functions with no arguments.
* [x] treat ambiguities as errors, raise exceptions.
* [ ] test dispatching on classes (like `TensorProduct` which appears twice in SymPy)
* [ ] test mixed function/class as dispatching elements (thanks to duck typing)
* [ ] should we have a global index of all dispatch occurrences within sympy? I mean, if a user has only partially loaded the dispatched function occurrences, how should he be treated when he tries to dispatch an unloaded function?
* [ ] add a `method=False` mode for dispatched methods?
* [ ] separate `DispatchedFunction` into `LocallyDispatchedFunction` and `GloballyDispatchedFunction` ?