Add numexpr option for lambdify

Sometimes numpy just isn't fast enough....

```python
In [1]: from sympy.abc import x, y, z

In [2]: from sympy import lambdify, S

In [3]: import numpy as np

In [4]: a, b, c = np.random.randn(300000).reshape((3, 100000))

In [5]: f = lambdify((x, y, z), 3*x**2+2*(y-z)+S('sin')(z**3)+S('exp')(x*y-z), modules="numpy")

In [6]: ff = lambdify((x, y, z), 3*x**2+2*(y-z)+S('sin')(z**3)+S('exp')(x*y-z), modules="numexpr")

In [7]: np.allclose(f(a, b, c), ff(a, b, c))
Out[7]: True

In [8]: %timeit(f(a, b, c))
10 loops, best of 3: 22 ms per loop

In [9]: %timeit(ff(a, b, c))
100 loops, best of 3: 2.07 ms per loop

In [10]: 
```
My functions tend to be long but simple as in the example above, so I haven't tested this extensively on more complex functions.  If those interested in this could post any successes/failures that would be appreciated! 
I did some more research on `numexpr`.  Here's another snippet from the docs

```
The only drawback of the new virtual machine is during the computation of small arrays:

>>> a = np.arange(10)
>>> b = np.arange(10)

>>> timeit ne.evaluate("a*(b+1)")  # 1.4.2
10000 loops, best of 3: 22.1 µs per loop

>>> timeit ne.evaluate("a*(b+1)")  # 2.0
10000 loops, best of 3: 30.6 µs per loop
i.e. the new virtual machine takes a bit more time to set-up (around 8 µs in this machine).
However, this should be not too important because for such a small arrays NumPy is always a
better option:

>>> timeit c = a*(b+1)
100000 loops, best of 3: 4.16 µs per loop 
```

I'm not so sure that numexpr will work for your use case.  Maybe there's something clever that can be done with numba here but that's for another PR