s,$/,,g,
eval
[download]

$|--;
print join $",
    map {
        $_[$_{$_}] = sub {
            join $,, map {
                       $_  = (ord) - ( $_[0] ? ($_[0]+4+$=)*$= : $= );
                       $_ += (2+$=)*2 while $_ < (1<<$.)-2-3*$=;
                       chr
            } split $,, pop
        } -> ($_{$_}, $_)
    }

    map {
        $_{$_} = $a++;
        $.++;
        $_
    }

    map {
        y; ;;d;
        $= /= 1.5;
        $.++;
        $_
    }

    sub {
        split $/, join q,,, <DATA>;
        unshift @_, map {
            $. = y---c - $|--;
            $_
        } shift;
        {
            undef @;;
            map @{[ push @{ $;[ ord((/.{$.}(.)/)[$|]) ] }, $_ ]},@_;
            @_ = map @$_, @;;
            $.-- && redo
        }
        @_[$|--..$^F+$|]
    } -> ()
[download]

$|--;
This sets $| to 1 (using the special behaviour of $|).

The next section of code that executes is the innermost anonymous sub:
    split "\n", join '', <DATA>;
Here we pick up the words that are at the end of the file, using split to fill @_. This is equivalent to @_ = <DATA>; chomp @_; or even just @_ = qw(uhinbyl zobxiiv xqsauh zozmib xtbemz ujwq xzaf ufde); to completely avoid the use of DATA.

    unshift @_, map { $. = (length) - $|--; $_ } shift;
The code block in map returns $_, and unshifts back onto @_ the same value it shifted off. So here map is only operating on one value, and only running for its side effects. In this case, $. gets set to 6, the length of "uhinbyl" - 1, and $| gets flipped back to 0.

    {
        undef @bins;
        map @{[ push @{ $bins[ ord( (/.{$.}(.)/)[$|] ) ] }, $_ ]}, @_;
        @_ = map @$_, @bins;
        $.-- && redo
    }
[download]

So, what ord returns is the code for the character at a given position. map here is in void context, so we are throwing away the return value from push. So it's equivalent to push @{ ... }, $_ for @_;. The push uses the output from ord as the index to an array (@; in the original code, which I have renamed to @bins here.) That array position becomes an arrayref, which will hold everything that maps to that ordinal.

So the first pass through, when $. is 6:

$bins[ ord('l') ] = [ 'uhinbyl' ];
$bins[ ord('v') ] = [ 'zobxiiv' ];
$bins[ 0 ] = [ 'xqsauh', 'zozmib', 'xtbemz', 'ujwq', 'xzaf', 'ufde' ];
[download]

The rest of the code is less interesting:
@_[$|--..$^F+$|]
$|-- returns 0 (the old value of $|) and flips it back to 1. $^F is 2, which added to $| - which just got flipped to 1 - yields 3. So this is actually @_[0..3], or a slice of the first 4 elements of @_. Yes, the other elements in DATA are thrown away - they are only there to misdirect. We end up with qw(ufde uhinbyl ujwq xqsauh).

The next two maps return $_, so they are again just doing side-effects:

    map {
        y/ //d;         # delete spaces.  None of the words have any, 
+so no-op.
        $= /= 1.5;      # $=, initially 60, can only contain integer v
+alues.
                        # Since map runs this 4 times for the 4 elemen
+ts of @_
                        # $= becomes 60 -> 40 -> 26 -> 17 -> 11
        $.++;           # The test ($.-- && redo) ended at 0, which me
+ans that
                        # $. ended up with the value -1.  Here it beco
+mes 3
        $_
    }
[download]

    map {
        $_{$_} = $a++;  # %_ hash becomes
                        # ( ufde=>0, uhinbyl=>1, ujwq=>2, xqsauh=>3 )
        $.++;           # 4 more increments leaves $. set to 7
        $_
    }
[download]

    map {
        $_[$_{$_}] =            # $_{$_} is the hash value that was
                                # just set to the array index
            sub {
              ...
            } -> ($_{$_}, $_)   # hash {$_}, $_ = (value, key) pair
    }
[download]

$_[0] = sub { ... } -> (0, 'ufde')
$_[1] = sub { ... } -> (1, 'uhinbyl')
$_[2] = sub { ... } -> (2, 'ujwq')
$_[3] = sub { ... } -> (3, 'xqsauh')
[download]

    join '',
    map {
       $_  = (ord) - 11 * ( $_[0] ? ($_[0]+15) : 1 );
       $_ += 26 while $_ < 93;
       chr
    }
[download]