Don't overwrite the `variables` argument to `Results.to_df` within the
method body with another computed value.

Instead of using a `filters` attribute to filter result `DataFrame`
columns, use an additional `filters` argument to `to_df` to achieve the
same result. Replace `functools.cache` on `to_df` with only caching
unfiltered results manually because `functools.cache` would interact
badly with the new `filters` argument.
This new implementation allows easy usage of different custom filters
without instantiating multiple `Results` objects and without constantly
recomputing the results `DataFrame`.
Note that default filtering is still done via a `filters` attribute.

Create as special `dict` subclass for `Filters` for `Results`. The
subclass as a special `updating` method, which is functionally
equivalent to `dict`'s `update` method, except that it doesn't update in
place, but creates a shallow clone and returns the `update`d clone.
The idea is that this enables combining the default `Results.filters`
easily with custom ones by doing e.g.:

```python
def nosinks(column):
    return not isinstance(column[1], Sink)

results.filters = Results.filters.updating({"flow": nosinks})
flows = results["flow"]
```

Note that the code making `Results.filters` a `Filters` instance instead
of a regular `dict` is not properly formatted yet. This is intentional,
in order to make it easier to spot that the code didn't change
semantically beyond adding the `Filters` call. Formatting will be done
in the next commit.

No semantic changes. Just formatting.

Not applying any filtering at all as a default is a special feature of
the `Filters` class, so the implementation should be placed there,
instead of making it the call site's responsibility to supply that
default.

Quench a `flake8` complaint.

Helps when comparing them between script runs.

The `Filters` class is intended to be a special dictionary holding
filter functions as values, so it's `__getitem__` function should return
such functions and, consequently, have an appropriate return type.

I added a function "hide_and_rename" to the examples to show what I
need. For me it is already fine to have this function but we should
think about a way to make the functionality of this function available
for others in a simple way (callbacks, filters etc.)

Using `DataFrame.loc` instead of `[]` squelches the
`SettingWithCopyWarning`s.
It's IMHO also a lot more readable than making the reader figure out
which of the many behaviours of `DataFrame`'s or `Series`'s overloaded
`[]` implementation actually gets used.

It's consistent with `Callbacks.noop` and uses context to avoid
redundant information. It should be clear that a `noop` in the context
of `Filters` means using no filter, so there's no need to repeat the
context in the name of the function.

Cast `Results.get`'s `filters` and `callbacks` arguments to `Filters`
and `Callbacks` before using them, thus allowing normal dictionaries to
be used when supplying values for these arguments. Among other things,
this allows the usage of empty `dict`s as an easy way to disable
defaults.

At least in one example. Leave the other one be for now, to illustrate
the difference.

This method could be defined (just `pass` inside the method) also with
the Node class of oemof.network