To simplify the low-level implementation of iloc-based getitem on both
Series and DataFrames, change the dispatching approach to parse the
user-provided "unstructured" key into structured data (a tagged
union using an enum + tuple). At the libcudf level, there are four
styles of indexing we can do:

1. index by slice
2. index by mask
3. index by map
4. index by scalar

iloc keys are parsed into information that tags them by type and
normalises the key to an appropriate column or other low-level object.

This centralises the business logic for index parsing in a
single place, and ensures that downstream consumers of the validated
and normalised indexer don't need to inspect it again to determine
what to do. Note that we treat index by scalar as composition of index
by map with get_element (since that simplifies the logic when
extracting the single row of a dataframe: we want to keep it on
device), but the scalar "type tag" allows us to determine this
unambiguously without reinspecting the key.

The major benefits will come when updating loc-based getitem (where
the parsing rules are more complicated, but eventually turn into one
of the above four cases). In this latter case, we will no longer
attempt to turn a loc-based key into a "user-facing" key for iloc, but
rather will call directly into the pre-parsed interface.

That said, we already provide some performance improvements since we
only do inspection once.

- Closes rapidsai#13013
- Closes rapidsai#13267
- Closes rapidsai#13515

Can't use libcudf.copying.gather since we need to do some
post-processing on categorical and struct columns. Staying in the
Series API gets us that for free.

Also use dataclasses as poor man's ADTs rather than tuple with tag
field.

Some renaming.

…ndexing-parse

Rather than having free functions to construct the witness types, the
default constructor validates correctness, and a classmethod
from_column_unchecked allows one to build a witness type asserting
correctness by fiat.

…ndexing-parse