Issue title: BUG: Complex numbers having an np.inf part return the wrong value when multiplied
 Issue body: ### Describe the issue:

While investigating #20291, I found out that multiplication of a complex number having `np.inf` as one of its parts with

1. a real number (imaginary part `0`)
2. a purely complex number (real part `0`)

returns an incorrect result.

### Reproduce the code example:

```python
import numpy as np

print((np.inf + 1j) * 2)
print((np.inf + 1j) * 2j)
print(complex(1, np.inf) * 2)
print(complex(1, np.inf) * 2j)
```


### Error message:

```shell
(inf+nanj)
(nan+infj)
(nan+infj)
(-inf+nanj)
```


### NumPy/Python version information:

1.21.4 3.9.7 (default, Oct 10 2021, 15:13:22) 
[GCC 11.1.0]
 Comments: 
 Comment 0: # Reason

This is how CPython defines [multiplication between two complex objects](https://github.com/python/cpython/blob/cbab997efb3ba5123dc8d9f706184fa8e634b3ec/Objects/complexobject.c#L54-L61):

```C
Py_complex
_Py_c_prod(Py_complex a, Py_complex b)
{
    Py_complex r;
    r.real = a.real*b.real - a.imag*b.imag;
    r.imag = a.real*b.imag + a.imag*b.real;
    return r;
}
```

The errors above occur because `np.inf * 0` is `nan`.

# SymPy

The same computations in SymPy, which does not use the multiplication operation defined by CPython:

```python
>>> complex(sympy.simplify((sympy.oo + 1j) * 2))
(inf+2j)
>>> complex(sympy.simplify((sympy.oo + 1j) * 2j))
(-2+infj)
>>> complex(sympy.simplify((1 + sympy.oo * 1j) * 2))
(2+infj)
>>> complex(sympy.simplify((1 + sympy.oo * 1j) * 2j))
(-inf+2j)
```

# Infinite Imaginary Part Initialization

As an aside, complex numbers with an infinite imaginary part cannot be instantiated with the `real + imag * 1j` syntax because of this. You have to use the constructor instead.

```python
>>> 1 + np.inf * 1j
(nan+infj)
>>> complex(1, np.inf)
(1+infj)
```
 Comment 1: I agree with the strict real `times` complex. This should not be a problem (unless I have missed something in IEEE 754).

But when you have a complex number with one of the terms being 0, then nan is the correct ieee 754 value: `inf * 0 == nan`. 

https://wiki.analytica.com/index.php/INF,_Nan,_Zero_and_IEEE/SANE_arithmetic

Other sites confirm this.

So basically it seems to be problematic due to reals being converted to complex numbers.
 Comment 2: Yeah, `inf * 0 == nan` is correct behaviour.

Multiplication with `0` always returns `0` in Python, so the formula for calculating the real and imaginary part is not a problem there. But, it is a problem in numpy because of `inf`. One of the parts being `0` returns a `nan` which shouldn't happen.

> But when you have a complex number with one of the terms being 0, then nan is the correct ieee 754 value: `inf * 0 == nan`.

Mathematically:
```
(0 + 2i) * ∞ = 2i * ∞ = ∞i
```

In numpy:

```python
>>> complex(0, 2) * np.inf
(nan+infj)
```

You don't consider the multiplication of `0` with `∞` when solving it analytically. Python does multiply `0` with `inf`, which is the problem here.
{'source': 'GithubIssues', 'repo_name_with_owner': 'numpy/numpy', 'issue_id': 1048661989, 'repo_stars': 21855.0}