Escaping the prison - finding the shortest way
Reviewing Code:

Names

When naming classes in hierarchies, share the naming conventions used in the standard libraries.  Therefore, your top level interface should be Maze, not IMaze.  Likewise, IMazePosition.

Repetition

You are repeating yourself both small and large here.

Small: notice that you repeat yourself for each of the cardinal directions (north, south, east, west).  That code is screaming for a loop:

for(MazePosition nextPosition : crntPosition.getNeighbors()) {
    if (maze.canMove(nextPosition)) candidates.add(nextPosition);
}


Large: notice that solveUsingDepthFirst and solveUsingBreadthFirst are the same except that they order the points differently.  This suggests that you have overlooked an abstraction: a SearchOrder.

public interface SearchOrder {
    boolean isEmpty();
    MazePosition next();
    void add(MazePosition candidate);
}

public class DepthFirstSearchOrder implements SearchOrder {
   Stack&lt;MazePosition&gt; stack = new Stack&lt;MazePosition&gt; ();

   // implement the interface accessing this.stack 
}

public class BreadthFirstSearchOrder implements SearchOrder {
   // notice that candidates is a List&lt;&gt;, because the interface
   // really doesn't care about the implementation.
   List&lt;MazePosition&gt; candidates = new LinkedList&lt;MazePosition&gt; ();

   // implement the interface using this.candidates
}

void solveUsingBreadthFirst(Maze maze) {
    solve(maze, new BreadthFirstSearchOrder());
}

void solve(Maze maze, SearchOrder order) {
    // ...
}


Missing Requirements

It looks like you aren't keeping track of the moves you have made; your existing example seems to tell you if a solution exists, but it doesn't actually report what the solution is.  This may or may not be a flaw - depending on the requirements.

Also, it's not fair to assume that your shortest solution in among them.  Imagine a maze that is a big ring, with the exit right next to the start - your depth first search can go the wrong way around the ring, giving you the longest solution instead of the shortest.  (The first result found in a breadth first search will be the shortest).

What you are missing is the ability to measure how far you have traveled when you reach the exit.  So you need something to count the number of moves you have made, so that you can tell if the current path you are taking has improved on your best so far.

If you had such a thing, you could (by generalizing it further) abandon search branches when they are guaranteed to be worse than the solution you have already found....