Quaternion: Fix bug where operations are left unevaluated
Quaternion: Fix bug where operations are left unevaluated

There are several operations on quaternions which are left unevaluated
in some common situations. One of the most obviously problematic one
is the following, which is actually part of the tests on this module.

```python
>>> from sympy import Quaternion, symbols
>>> x, y, z, w = symbols('x y z w')
>>> q = Quaternion(x, y, z, w)
>>> q.normalize()
x + y*i + z*j + w*k/sqrt(w**2 + x**2 + y**2 + z**2)
>>> type(q.normalize())
<class 'sympy.core.mul.Mul'>
```

Here, `q.normalize()`, instead of returning a quaternion, returns an
unevaluated `Mul` object. The expected output would have been an
instance of `Quaternion` whose arguments are `x/sqrt(w**2 + x**2 +
y**2 + z**2)`, `y/sqrt(w**2 + x**2 + y**2 + z**2)`, etc.

The test for this is `assert q.normalize() == Quaternion(x, y, z, w) /
sqrt(w**2 + x**2 + y**2 + z**2)`. It passes, but both sides of the
equation are not quaternions, which is not what we would expect.

There are two reasons for this bug:

1. Division for quaternions is not implemented. For instance, `q / 2`
is left unevaluated.

2. Operations between a quaternion and an expression which is neither
a quaternion nor a complex number is left unevaluated. For example, `q
* q.norm()**-1` is left unevaluated since `(q.norm()**-1).is_complex`
is `None`.

Both problems have been corrected.

kaushik94/sympy,kaushik94/sympy,kaushik94/sympy