Shortest distance from one word to another. eg: cat -> cot -> dot -> dog
I'm not sure about the exact complexity, but it is certainly huge! One-letter edits are fine to spell check one word given a large dictionary, but does not work if you only have a few words and the edit distance can be arbitrarily large. To look for close words in the dictionary, you should use the Levenshtein distance, as mentioned by ratchet freak. (Implementing the Levenshtein distance is a good idea.)

//        dictionary = new TreeSet&lt;String&gt;();
//        ....


Please don't post unused code here unless you want it reviewed too.

private CatToDog () { };


A default constructor is provided by Java already, only use that if you need to put something in there.

public static List&lt;String&gt; listWords(String startWord, String endWord) {
    final Queue&lt;String&gt; queue = new LinkedList&lt;String&gt;();
    final Map&lt;String, String&gt; backTrack = new HashMap&lt;String, String&gt;();
    queue.add(startWord);
    backTrack.put(startWord, null);

    while (!queue.isEmpty()) {
        String currentWord = queue.poll();
        if (currentWord.equals(endWord)) {
            return mapToList(backTrack, endWord);
        }
        addValidOneChangeWords(currentWord, queue, backTrack);
    }
    return Collections.EMPTY_LIST;
}


How do you know this is the shortest path? It feels a lot like depth first search, but I think you want to implement Dijkstra's algorithm instead to be able to notice shorter subpaths.

private static void addValidOneChangeWords(String startWord, Queue&lt;String&gt; queue, Map&lt;String, String&gt; backTrack) {
    for (int i = 0; i &lt; startWord.length(); i++) {
        char[] endWord = startWord.toCharArray();
        for (char ch = 'a'; ch &lt; 'z'; ch++) {
            endWord[i] = ch;
            String word = new String(endWord);
            if (validate(word, backTrack, startWord)) {
                queue.add(word);
                backTrack.put(word, startWord);
            }
        }
    }
}


You're only focusing on one-letter edits here, but what about deletions, insertions and even transpositions (dog -> dgo)? The Damerau-Levenshtein distance handles them. 

And finally, mapToList is poorly named: I already know that the type change, I want to know about semantics! Something like editPath would be better.