Matching Adjacent Words In this challenge, you are passed two words: Your job is to determine if they are adjacent.
Two letters are adjacent if:

They are the same letter, or
They are lexicographically adjacent.

For example, J is adjacent to I,J, and K only.  Z is not adjacent to A
Two words are adjacent if:

They are the same length, and
Each letter is adjacent to a unique letter in the other word.

For example, CAT is adjacent to SAD, as C&gt;D, A&gt;A, T&gt;S.
FREE is not adjacent to GRRD (each E needs a letter to pair with).
Input/Output
You are passed two strings, and you need to return a truthy value if they are adjacent, otherwise a falsy value.  You should return within a minute for all test cases below.
You can assume that the strings will only contain uppercase, alphabetic letters.
The two strings can be passed as a list, or concatenated, with or without quotes.
Test Cases
Truthy:
A A
A B
C B
DD CE
DE FC
ABCD BCDE
AACC DBBB
DJENSKE FDJCLMT
DEFGHIJKL HJLEHMCHE
IKLIJJLIJKKL LJLJLJLJLJHI
ACEGIKMOQSUWY BLNPRDFTVHXJZ
QQSQQRRQSTTUQQRRRS PQTTPPTTQTPQPPQRTP
ELKNSDUUUELSKJFESD DKJELKNSUELSDUFEUS

Falsy:
A C
A Z
B J
JK J
CC BA
CE D
DJENSKE GDJCLMT
DEFGHIJKL HJLHMCHE
IJKLIJKLKIJL LIJLLHJLJLLL 
AWSUKMEGICOQY RSHXBLJLNQDFZ
QQSQQRRQSTTUQQQRRS PQTTPPTTQTPQPPQRTT
ELKNSDUVWELSKJFESD DKJELKNSUELSDUFEUS

This is code-golf, so the shortest valid answer wins!
CJam, 14 13 12 bytes

r$r$.-:)3,-!


Try it online! or verify all test cases at once.

Algorithm

Let s and t be two sorted words of the same length. For s and t to be lexicographically adjacent (LA), it is necessary and sufficient that all pairs of its corresponding characters are also LA.

The condition is clearly sufficient for all words, and necessary for words of length 1.

Now, assume s and t have length n > 1, and let a and b be the first characters, resp., of s and t.

Since s and t are LA, there is some bijective mapping &phi; between the characters of s and the characters of t such that x and &phi;(x) are LA for all x in s, meaning that |x - &phi;(x)| &leq; 1 for all x in s.

Let c = &phi;(a) and d = &phi;-1(b). Because of a's and b's minimality, a &leq; d (1) and b &leq; c (2).

Furthermore, since b and d, and a and c, and LA, d &leq; b + 1 (3) and c &leq; a + 1 (4).

By combining (1) and (3), and (2) and (4), we get that a &leq; d &leq; b + 1 and b &leq; c &leq; a + 1, from which we deduce that a - 1 &leq; b &leq; a + 1 and, therefore, that a and b are LA.

Now, by combining (1) and (4), and (2) and (3), we get that c - 1 &leq; a &leq; d and d - 1 &leq; b &leq; c, from which we deduce that c - 1 &leq; d &leq; c + 1 and, therefore that c and d are LA.

Thus, if we redefine &phi; by &phi;(a) = b and &phi;(d) = c, |x - &phi;(x)| &leq; 1 will still hold for all x in s and, in particular, for all x in s[1:].

This way, s[0] = a and t[0] = b, and s[1:] and t[1:], are LA.

Since s[1:] has length n - 1, this proves the necessity by induction.

Code

r               e# Read the first word from STDIN.
 $              e# Sort its characters.
  r             e# Read the second word from STDIN.
   $            e# Sort its characters.
    .-          e# Perform vectorized subtraction.
                e# This pushes either the difference of char codes of two
                e# corresponding characters or a character that has no does not
                e# correspond to a character in the other, shorter word.
      :)        e# Increment all results.
                e# In particular, this maps [-1 0 1] to [0 1 2].
        3,      e# Push the range [0 1 2].
          -     e# Perform set difference, i.e., remove all occurrences of 0, 1 and
                e# 2 from the array of incremented differences.
           !    e# Apply logical NOT. This gives 1 iff the array was empty iff
                e# all differences gave -1, 0 or 1.