backend: refactor action handlers to their separate classes
The current implementation is too clumsy and IMHO stops being good
enough. We have one gigantic class `Action` which does everything.
It implements methods to handle every possible type of an action.
Then `run()` method parses action data, determine what type
of action it is and call an appropriate handler method.
This doesn't make much sense in the first place. We should have
specific classes for each and every type of an action. This way
we will have those classes responsible for only one thing and
the chance that they will affect each other is lower.
Moreover, the current solution doesn't allow to easily define
action type scpecific properties, such as its priority. Therefore,
I decided to refactor our current implementation.
While I was at it, I refactored the `result` behavior. There was
TODO: we don't need Munch() here, drop it
result = Munch()
which is true. We created `result` munch only to store basically
just one value - the integer value of the actual result (and id,
which was useless). Then we would pass it to each hander method
just so it can update its value. That's so C++.
I threw away the whole "result" concept. Actions don't take `result`
as their parameter anymore and simply return the result value. Not
a munch, but the actual integer result value that we are interested