Instead of Stack (which uses synchronized), we would prefer to use ArrayList<DeltaVisit> with stack.remove(stack.size()-1) for the pop operation.  This way the JIT doesn't need to work to optimize out the locking.

FWIW though, this is such a simple usage that I would make the stack myself and avoid all of the extra work that ArrayList (or Stack/Vector) impose on each operation:

  private void resolveDeltas(DeltaVisit visit) ... {
    while (visit != null) {
      visit.data = ...;

      visit.nextChild = firstChildOf(oe);
      visit = nextVisit(visit);
    }
  }

  private static DeltaVisit nextVisit(DeltaVisit visit) {
    // If our parent has no more children, discard.
    while (visit.parent != null && visit.parent.nextChild == null)
      visit.parent = visit.parent.parent;

    do {
      UnresolvedDelta childId = visit.nextChild;

      if (childId != null) {
        visit.nextChild = childId.next;
        return new DeltaVisit(childId, visit);
      }

      visit = visit.parent;
    } while (visit != null);
  }

  private static class DeltaVisit {
    final UnresolvedDelta id;
    DeltaVisit parent;

    byte[] data;
    UnresolvedDelta nextChild;
  }

I like this solution because its still fairly short, but saves a lot of overhead.  It also give us a nice tail-recursion case to discard an object as soon as its last child is inflated, reducing the memory usage for long delta chains that have only 1 object at each level.