ENH: add fast DataFrame iterator that doesn't rename columns
Hello, everyone.

#### Is your feature request related to a problem?

So we have come across a problem at work. We often pre-process data by feeding generators into each other. In order to be able to work with rows independently and not store meta information somewhere, these rows are fed through as dicts where the keys are column names. The datasets can be a dozen gigabytes in size.

DataFrame objects are convenient for a lot of purposes, including the ease of vectorized operations, but to use them, we need to be able to feed the DataFrame row by row into the pipeline. None of the DataFrame iterators we have in pandas get the job done without wrappers or cludges:

* `iteritems` iterates over columns, so it's a no-go;
* `iterrows` does type conversion, and we need to preserve original types. It's also slow;
* `itertuples` returns a `namedtuple`, which can't be relied upon, because it renames columns.

#### Describe the solution you'd like

Passing data through the pipeline as a dict of `column: value` pairs is quite common, I believe. Can we add a `DataFrame.iterdicts` method that would return rows as `OrderedDict` to guarantee column order and preserve their names and types?

#### API breaking implications

None. Adding a new method to the `DataFrame` API.

#### Describe alternatives you've considered

We had to cludge this by doing something like:

```python
def iterdicts(df):
    """
    Yield a dictionary for each row of `df`.
    :param df:
    :return:
    """
    col = df.columns
    for row in df.itertuples(index=False, name=None):
        yield dict(zip(col, row))
```

I think anyone can do this for themselves, but it would be nice to have such a convenience method as part of the native API.

Another alternative is to move the warning about `itertuples` renaming columns to the very top of the doc. This, at least, will ensure that someone who needs to read a hundred docs a day at work won't miss it, and then end up with a bug that pops up only on some datasets.

#### Additional context

Heard the same complaint at my previous workplace, but there I could answer with, 'Have you heard of apply and all the pre-programmed Cython functions in pandas?' With most datasets, the preferred approach should be to use vectorized operations, and it makes sense to get pandas iterators convenient and good enough, and then leave them at that.

But when you are pushing around dozens of gigabytes of data in an environment with parallelization, network IO, and a lot of other stuff, it becomes unviable to process the entire dataset in a DataFrame (or an ndarray, for that matter). And other parts of the pipeline take up the majority of its runtime, so processing it row by row is the optimal way to code this, when the preprocessing operations are sufficiently complex and spread out.

I believe that the need for this iterator is widespread enough to add it to the pandas API, but I'm biased as I didn't read the docs far enough down (as you do, when you are in a hurry), and then spent half a day debugging the solution only to discover that some datasets have columns that are invalid python names and get renamed. This is probably the worst part about `itertuples` being the fastest option recommeded for such a use case right now: you code a pipeline, and then it breaks only on some datasets.