PERF: always slice when indexing on columns
- [ ] closes #xxxx
- [x] tests added / passed
- [x] passes `black pandas`
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [ ] whatsnew entry

Touched on in #32779, this makes all\* DataFrame indexing-on-columns do slicing instead of taking, so doesn't make copies.

\* Actually there is a different path in `_slice_take_blocks_ax0` that we go down if we `self._is_single_block`, can update that later if we decide this is something we want to do.

```
In [3]: dti = pd.date_range("2016-01-01", periods=10**5, freq="S")                                                                                                                                                  
In [4]: df = pd.DataFrame._from_arrays([dti]*10 + [dti - dti] * 10 + [dti.to_period("D")]*10, columns=range(30), index=range(len(dti)))                                                                             

In [8]: arr = np.arange(30)                                                                                                                                                                                         
In [9]: np.random.shuffle(arr)                                                                                                                                                                                      

In [10]: %timeit df[arr]
8.35 ms ± 64.1 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)    # <-- master                                                                                                                                                     
650 µs ± 52.5 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)   # <-- PR
```

The tradeoff is that we end up with less-consolidated results.  I'm OK with that, but there may be downsides I'm not aware of, will wait for others to weigh in.