[FEA] Add partial row tabular tokenizer, 'best' transform for FloatCode, and refactor
**Is your feature request related to a problem? 
TabularTokenizer and ColumnCode api needs QOL improvements. It currently does not support partial row generation because of [this](https://github.com/NVIDIA/NeMo/blob/main/nemo/collections/common/tokenizers/tabular_tokenizer.py#L132) and [this](https://github.com/NVIDIA/NeMo/blob/main/nemo/collections/common/tokenizers/tabular_tokenizer.py#L164), impacting certain generative applications. because it expects all the columns and the columns to be in order.

**Describe the solution you'd like**
- add 'best' transform into FloatCode, and include new transforms, with some simple stats/heuristics for selecting a 'best' transform
- refactor column_coder.py into datatype_code and column_code to separate out the datatypes that a column has from the column_code.
- refactor Code into a code_spec, and add a NumericCode base class inheriting from Code. Push fill_all and has_nan into NumericCode as those params are only useful for numeric dataytypes
- add a partial row encoder and decoder for the tabular tokenizer
- rename some class methods to be more clear, ex. array_convert_to_int to transform_data_to_int_array to more accurately describe the function
- Fix `bug` where the [FloatCode accuracy ](https://github.com/NVIDIA/NeMo/blob/main/nemo/collections/common/tokenizers/column_coder.py#L231) leads to cases where the decoded output is less accurate than it needed to be.
- remove `column_coder.py` and replace it with `datatype_code`. Uses `code` over `coder` since `code` is for a mapping of the dtype col itself.
- write tests

A clear and concise description of what you want to happen.
Tests will clarify usage. ex. 
```
from datatype_code import FloatCode

float_code = FloatCode('name', code_len=3, start_id=0, fill_all=True, base=100, has_nan=True, transform='identity')
float_code.compute_code(data_series)
```
This keeps the new code that users will interface with inline with the current API.

**Describe alternatives you've considered**
putting `compute_code` into the into a `fit_transform`, and encode as `transform` and decode as `inverse_transform` to make the API similar to sklearn.

A clear and concise description of any alternative solutions or features you've considered.
- instead of tokenizing the text token by token. Group the tokens by column and tokenize by column in a vectorizable fashion. This speeds up decoding a lot. Even converting to a DataFrame and doing a `df.replace` or `map` will speed up over existing method. The caveat is this will not allow for partial row generation.
- other vector based methods or parallel lookup methods to speed up encoding and decoding as this consumes quite a bit of time.

