Overall, it likely doesn't matter much for performance, but it is
more logical and more consistent with what python does: reverse
operators are not called if the forward one of a given class
already returned NotImplemented.

Code was getting too convoluted and both can be optimized
in different ways.

Using the realization from inspecting similar CPython code that as we
intern string names anyway, comparing keys with possible names by
pointer will generally just work.

Also rather drastically rewrote, ot use simple conversion functions
instead of the enormous switch/case loop (except for "out").

Reduces the overhead as follows:
```
import numpy as np
a = np.array(1)
b = np.empty_like(a)
%timeit np.positive(a)                                 # 352->348 ns
%timeit np.positive(a, subok=True)                     # 606->501 ns
%timeit np.positive(a, where=True)                     # 586->503 ns
%timeit np.positive(a, where=True, subok=True)         # 695->531 ns
%timeit np.positive(a, b)                              # 354->352 ns
%timeit np.positive(a, out=b)                          # 557->480 ns
%timeit np.positive(a, out=b, subok=True)              # 668->506 ns
%timeit np.positive(a, out=b, where=True, subok=True)  # 752->536 ns
```

The argument parsing for ufuncs contains special logic to enable returning
NotImplemented for comparison functions.  The ufuncs, however, should
not have to know whether they were called via a python comparison operator,
so this PR moves the logic to the operators, checking after ufunc failed
whether a NotImplemented should be returned.

This since "out" can no longer be present.

Could be together with simplifying array_wrap.