cache autowrap

cache results of autowrap following discussion of #7973.

Sample session:

```python
In [1]: from sympy.utilities.autowrap import autowrap

In [2]: from sympy import (
    symbols, lambdify, sqrt, sin, cos, tan, pi, atan, acos, acosh, Rational,
    Float, Matrix, Lambda, exp, Integral, oo, I, Abs, Function, true, false)

In [3]: w, x, y, z = symbols('w,x,y,z')

In [4]: expr = sin(x) + cos(y) + tan(z)**2 + Abs(z-y)*acos(sin(y*z)) + \
           Abs(y-z)*acosh(2+exp(y-x))- sqrt(x**2+I*y**2)

In [5]: %time bin = autowrap(expr)
CPU times: user 100 ms, sys: 14 ms, total: 114 ms
Wall time: 1.12 s

In [6]: bin(1, 2, 3)
Out[6]: 2.9323081800586097

In [7]: %time bin = autowrap(expr)
CPU times: user 0 ns, sys: 0 ns, total: 0 ns
Wall time: 41.7 µs

In [8]: bin(1, 2, 3)
Out[8]: 2.9323081800586097
```
caching the function's results involves computing the hash of the args.  The default kwargs are not cached but then one gets very strange behavior:

```python
In [1]: from functools import lru_cache 

In [2]: @lru_cache()
   ...: def f(a, b=[]):
   ...:     return (a, b)
   ...: 

In [3]: f(1)
Out[3]: (1, [])

In [4]: f(1, b=[])
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-4-cecbdaaeecad> in <module>()
----> 1 f(1, b=[])

/home/ptb/miniconda3/lib/python3.4/functools.py in wrapper(*args, **kwds)
    436                 # Size limited caching that tracks accesses by recency
    437                 nonlocal root, hits, misses, full
--> 438                 key = make_key(args, kwds, typed)
    439                 with lock:
    440                     link = cache_get(key)

/home/ptb/miniconda3/lib/python3.4/functools.py in _make_key(args, kwds, typed, kwd_mark, fasttypes, sorted, tuple, type, len)
    366     elif len(key) == 1 and type(key[0]) in fasttypes:
    367         return key[0]
--> 368     return _HashedSeq(key)
    369 
    370 def lru_cache(maxsize=128, typed=False):

/home/ptb/miniconda3/lib/python3.4/functools.py in __init__(self, tup, hash)
    335     def __init__(self, tup, hash=hash):
    336         self[:] = tup
--> 337         self.hashvalue = hash(tup)
    338 
    339     def __hash__(self):

TypeError: unhashable type: 'list'

```
`cacheit` is essentially a wrapper around functools.lru_cache which catches the exception and simply calls the function with the unhashable arguments. Leaving the defaults as lists would incorrectly convey that lists were acceptable.

I could change the other default arguments in the file for a more consistent api