add literal keyword to evalf and use in assumptions

keyword "literal" will cause None to be returned if the
object cannot be evaluated to a literal number. The
attribute 'is_number' is often used to find out if something
can be evaluated to a number before attempting the evaluation,
but things like f(0) represent numbers (in an undefined sense)
that cannot be computed without knowing what f is.

So rather than

if foo.is_number and not foo.atoms(AppliedUndef):
  n = foo.evalf()
  if all(i.is_Number for i in n.as_real_imag()):
      pass

one can do

n = foo.evalf(literal=True)
if n is not None:
    pass

This is like using the strict
flag and catching the PrecisionExhausted error, but it will also
avoid the evaluation if there are unevaluable objects (like
AppliedUndef) present.

Notes:

is_zero is needed to identify alternate *trivial* forms of 0 as
in Integral(0, ...). It should never do more than look for a literal
0 someplace. For this reason, the Integral.is_zero routine was modified
and the advanced processing for other mostly trivial cases of an integral
being 0 was moved to the doit method.

foo.is_number is equivalent to not foo.free_symbols but is a faster way of
arriving at that answer because is_number will fail if a single free
symbol is encountered. For this reason, the Integral.is_number routine
was modified.

foo.free_symbols should give any free symbols in the expression *as
written* without any regard to whether those symbols will disappear after
simplification of some sort. The test for is_zero was removed from
expr_with_limits calculation of free symbols for this reason.

Other comments about the rationale of these changes are in the test
suite (esp in test_basic) so that anyone changing the behavior will be
sure to see the desired state of affairs.
only call evalf if doit did something
add check for is_zero in re and im
7642: KroneckerDelta more judicious evalf; = 0 for nonzero diff