Lambdify uses Dummy

Within lambdify, lambdastr specifically, all over the provided args are
replaced with Dummy symbols within the expr to be evaluated. This allows for
substitution of things with unfriendly names, such as AppliedUndef's (e.g.,
x(t)).

Before this failed:
  >>> t = symbols('t')
  >>> x = Function('x')
  >>> y = x(t)
  >>> lambdify(y, 2*y)

Now the above works.
Added test for lambdify changes

Now tests that providing an AppliedFunction as an arg into lambidfy actually
works.
Rewrote the changes to lambdify

Now in lambdastr, the default behavior is not to dummify everything; it is a
kwarg option. When lambdstr is called by lambdify though, dummify is set to
True. The justification for this is that if lambdastr is called directly by a
user, they might want to observe the output, in which case all Dummy symbols
would be confusing; if lambdify calls lambdastr, they won't be able to see the
output, and the lambdastr readability doesn't matter, making the increased
range of input arguments worth it.

In addition, translations from ImmutableMatrix -> matrix needed to be added, as
calling sympify on a Matrix results in an ImmutableMatrix.

A few tests were added to ensure that the new lambdify functionality works.
Rewrote lambdify for better usage of dummies

Now, dummies are only substituted in when a numerical output is going to be
used. Additionally, dummies are only substituted for args which are symbols or
functions. Tests added to make sure error is raised for incorrect usage.

Also, instead of using subs, it now uses xreplace.