dummy() function - What is that supposed to be?

where [dummy] is declared

In the declaration that you show. Simplified:

T f /* the declarator */, dummy /* the declarator */;

dummy is just a name of a variable, just like f. They are both declared in the same declaration.

Could someone explain what that dummy function (or functor) does

I mean obviously in the example it is used to call the function f. But what its actual purpose?

That is the actual purpose. The only reason it is declared, is so that f could be called within the same declaration, as was desired in the linked question. The solution is silly, but so is perhaps the desire.

Let's simplify the declaration a bit by using simpler types and expressions. We'll use int instead of std::function<void(int)>, 42 instead of the lambda, and f += 1 instead of f(3):

int f{42}, dummy((f += 1, 0));

To make it even more obvious, we can also use braces instead of parentheses for the second initialisation:

int f{42}, dummy{(f += 1, 0)};

This way, it should be clearer. It's a declaration which declares two variables: f and dummy. f is initialised with 42, and dummy is initialised with this expression: (f += 1, 0). That one's using the comma operator to first evaluate f += 1, discard the result, and then use the value 0 to initalise dummy.

Going back to the full (nonsimplified) declaration:

The type of both variables f and dummy is std::function<void(int)>. First f is initialised with a lambda. Then, dummy is initialised using a comma expression. The left-hand side of that expression, f(3), is evaluated and forgotten. The right-hand side, nullptr, is then used to initialise dummy. Initialising a std::function with nullptr results in creating an empty std::function object (the same as a default-constructed one).

The whole purpose of dummy is to introduce some extra context on the same line (= in the same declaration) in which f could be invoked.