Dispatching Brainfuck commands using if-else or dictionary
A few coding points:


I think you could simplify the arguments a lot by using kwargs, rather than passing a tuple of arguments.
Having your dict in the global namespace, rather than the function's local namespace, will slow it down considerably.  
0 is False, so if args[2] != 0: can just be if args[2].
For unused variables, like step, I consider it better to mark it as such by using _ as the variable name.
Half of the functions are simple one-liners that can use lambdas.
Although half of the functions can be lambdas, some of them would work better by doing in-place operations on memo.
If you want to search until the end, you don't need to specify an end to find.
You add 1 to i in every case, so that can be moved out of the functions.


As for your questions:

There are three major situations where I would use the dict structure.  


The functions can either be lambdas or external functions that are short and easy-to-read as dict values.  Usually this is better with only one or a few consistent arguments.
The functions are so long that putting them in an if chain makes it hard to keep track of the flow.  Again, usually this is better with only one or a few consistent arguments.
There are a huge number of possible inputs, which makes for an overly long if test chain, but where there are again only one or a few consistent arguments.


The problem with your case is that this is in-between, they are simple enough that you can follow the flow easily in an if test, but they are not all so simple that they can be put into lambdas without sacrificing clarity (it is possible to put all but one in lambdas, but half would be really hard to read).  Further, there are not so many situations that it becomes hard to read in an if chain (although it is getting close), and there are enough arguments (or enough inconsistency in the arguments) that it is getting to the point where I would not use the dict approach even if all the other criteria were satisfied (although again it is kind of borderline).

Ultimately, what it comes down to is whether the dict approach helps or hurts readability.  In your case, I think it hurts it.  If the criteria I described above hold, then it will probably help it (although you really need to look on a case-by-case basis, since there will be corner cases either way).