add docstring to as_dummy()
finite/infinite are now complex

If we assume finite == !infinite in assumptions, we
create an alias: finite=False is the same as infinite=True
and vice versa. We don't want to do that. What we want is
behavior like integer and noninteger:

Dummy(integer=0) is not the same thing as Dummy(noninteger=1).
A noninteger is commutative, complex, hermitian, noninteger,
nonzero, and real while integer=0 is only commutative -- nothing
else is known about it (other than that it is not 0).

/!\ In general, it is much easier to comprehend what one means
by using only true attributes to desccribe it. If something is
not zero but still complex, say nonzero=True instead of zero=False.

So assumptions.py has been modified to make the following true:

```
finite   : 0 <= abs(x) < oo
infinite : abs(x) == oo
make all NaN is_* properties None -> False

Since NaN is not even complex it cannot have any of the attributes of
the complex numbers. So things properties like positive, odd, etc...
should be False. For example, NaN never appears amongst
the postive numbers in the same way that S.NegativeOne never
appears amongst the positive numbers so False should be returned for both.

Returning False has no
other implication about what the object *is*, only what it is not.
None should be returned when there is a question about whether the
statement is true, as in Dummy(nonnegative=1).is_positive. Since the
symbol might be 0 or positive we cannot say for sure that it it
positive.

Returning None means "I don't know, ask someone else." When expressions
which could lead to a NaN are encountered _eval_is_ routines should
return False instead of None so that all routines should not have to be
queried to determine what the expression is. e.g. if an expression
zero*unbounded is encountered False for is_real and then all the
implications of that can be propogated by the assumptions system.
remove superfluous setting of assumptions in numbers.py

Having additional constraints on objects which are not
part of the assumption system makes changes in the assumption
difficult. The tests are the place to enforce requirements.