WIP: reduce unwanted type conversions of pd.Series.isin
Addresses the bug in pd.Series.isin(values) that sometimes undesirably converts the dtype of `values` to the the dtype of the series before the `isin` comparison. Here is an example where `values` is converted to `int`, and hence the output `(True, True)` is yielded, while `(True, False)` is expected:
```python
>>>  values = [1, 0.5]
>>> pd.Series([1, 0]).isin(values)
0    True
1    True
dtype: bool
```

In my understanding, the bug has two sources:

**1) L407-408 in `pandas/core/algorithms.py`**

```python
comps, dtype, _ = _ensure_data(comps)
values, _, _ = _ensure_data(values, dtype=dtype)
```
Here, first the dtype of the series (`comps`) is determined, and then `values` is forcefully converted to that dtype. This e.g. leads to the undesired conversion of the example above.

**2) L417-434 in `pandas/core/algorithms.py`**
```python
    elif is_integer_dtype(comps):
        try:
            values = values.astype('int64', copy=False)
            comps = comps.astype('int64', copy=False)
            f = lambda x, y: htable.ismember_int64(x, y)
        except (TypeError, ValueError):
            values = values.astype(object)
            comps = comps.astype(object)

    elif is_float_dtype(comps):
        try:
            values = values.astype('float64', copy=False)
            comps = comps.astype('float64', copy=False)
            checknull = isna(values).any()
            f = lambda x, y: htable.ismember_float64(x, y, checknull)
        except (TypeError, ValueError):
            values = values.astype(object)
            comps = comps.astype(object)
```
Here, if the dtype of the series (`comps`) is either `float` or `int`, a forced conversion of `values` takes place again.

The fix:
**1) L408ff**
Only force the dtype of `comps` to `values` if *both* are int-like, float-like, or datetime-like.  If not, use `_ensure_data(values)`  *without* the `dtype` argument. I tried to keep the cost of the dtype checks low by exploiting lazy evaluation.

**2) L432ff** 
Add `and` statements such that the conversion only takes place when *both* `comps` and `values` are either `float` or `int`. If they are none of the above is true, both are converted to `object` type in the `else` block. This ensures that `return f(comps, values)` works (since `f = lambda x, y: htable.ismember_object(x, values)` from L426).

- [x] fixes #19356
- [x] tests added / passed
- [ ] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [ ] whatsnew entry
