OK, reversible updates. You need to somehow store the parent state information in order to backtrack. And the natural way to do this is to push the edge/diff info in the stack. By doing so you only have to maintain one state at a time, keeping the backtrack information compact. But when to backtrack? You surely use iterative deepening, otherwise it returns a suboptimal path or may not backtrack forever on the state space graph. You also want to prune the states? Use the sum of the depth and the heuristic lower bound. This is IDA＊. You can call a blind IDA＊ as IDDFS too, but I generally just call them IDA＊. A plain DFS is not viable in complex problems, so let's forget about it.
> choosing which node (next state) to expand next
I know this is "heuristic search", a broader class of algorithms which includes A＊ and IDA＊ and many more. But the core selling point of IDA＊ is not the "heuristic search", but its compact linear-space memory usage (thus fast) compared to A＊. So I did not suggested IDA＊ because of its heuristic search aspect.
For an efficient implementation, reversible updates are just natural and common in IDA＊. Below is an excerpt from [1]. I believe this is equivalent to what you call reversible state updates.
* In-place Modification
The main source of remaining overhead in the expansion function is
the copy performed when generating each new successor (line 12 in Figure 1).
Since IDA＊ only considers a single node for expansion at a time, and because
our recursive implementation of depth-first search always backtracks to the
parent before considering the next successor, it is possible to avoid copying entirely.
We will use an optimization called in-place modification where the search
only uses a single state that is modified to generate each successor and
reverted upon backtracking.