Fix for the bug #7343
Fix for the issue #7342
Fix for the bug #7343

Corrected the bug by adding solutions returned from
each individual equation to the `sols` set. Previous
error was due to replacing the last solution in `sols`
by the new solution rather than appending it to the `sols`.
Fix for the issue #7342

Change the return type of `diop_solve()` to a tuple in the univariable
case. Also added the checks to ensure that only  `Add`, `Mul` or a
`Symbol` is processed in the `classify_diop()` function. Raised an
error in the other cases.
Replace `==` by `is`
Fixed merge conflicts.

Conflicts:
	sympy/solvers/diophantine.py
Use the shortened version of `isinstance`. Replaced
`isinstance(eq, Add) or isinstance(eq, Mull) or ....` by
`isinstance(eq, (Add, Mul, ...))

Replaced the search for `None` using a for loop by using
`in`.
Use iterators in `merge_solution` instead of using counter
variables to keep track of the next element to be taken out
from `params` and `solution`.
Use the function `numbered_symbols` for generating parameters
used in `merge_solution`
Add support for `Eq` and `Poly` in diophantine module.

In [1]: from sympy.solvers.diophantine import *

In [2]: diophantine(Poly(x+y))
Out[2]: set([(t, -t)])

In [4]: diophantine(Eq(x,y))
Out[4]: set([(-t, -t)])
Remove unnecessary imports `Add`, `Mul`, `Pow` and `Poly`.
`Add`, `Pow` and `Mul` had been imported already.
Moved the check for the allowed input formats from `classify_diop()`
to `diophantine()`. This make sense because the verfication of allowed
input formats should be done prior to the classification of the equation.

In [1]: from sympy.solvers.diophantine import *
In [2]: f = symbols("f", cls=Function)

Previously,

In [3]: diophantine(f)
TypeError: unbound method as_expr() must be called with f instance as first arg$

Now,
In [3]: diophantine(f)
TypeError: Equation input format not supported

Also, a test was added in `test_diophantine.py` to check whether the
exceptions are raised when the expected input formats are not found.

Also `Pow` was added to the supported input formats since it is possible
to solve the `Pow` types by `diophantine()`. Eventhough the exponential
diophantine equations are not explicitly supported, simple powers which
can be represented by `Pow` can be solved by `diophantine()` as the input
expression is treated as a `Mul` of (base, exponent) pairs.

In [4]: diophantine(x**y)
Out[4]: set([(0, n₁)])

In [5]: diophantine((x-y)**z)
Out[5]: set([(-t, -t, n₁)])
Update the docstring of `diophantine()` describing the output format
Replace the check for the correct input type with more elegant code.
Remove redundant `raise` statement.
Replace "univariable" with "univariate"
Use `Poly()` on the input
Merge branch 'master' into Fix_issues_#7342_#7343

Rebase over 'master' after merging #7448.

Conflicts:
	sympy/solvers/diophantine.py
	sympy/solvers/tests/test_diophantine.py
Merge pull request #7349 from thilinarmtb/Fix_issues_#7342_#7343

Fix two issues on the diophantine module