It's better to avoid checking all permutations if you can. Permutations grow in number very rapidly with string length.

You don't need to know which permutation gets you a dictionary word, only that one exists. You can do that by rearranging the characters of words in alphabetical order and matching with wildcards. We deal with 'location' in the form 'acilnoot'.

First, let's get the preliminaries out of the way...

#!/usr/bin/perl
use warnings;
use strict;
[download]

my ($wl, %words) = '/usr/dict/words';
{
    open my $wf, '<', $wl or die $!;
    chomp, push @{$words{join( '', sort split //, lc)}}, $_
        while <$wf>;
    close $wf
}
[download]

It would be nice to give several words on the command line, so we set that up in a hash which will hold results:

my %matches;
@matches{map {lc} @ARGV} = ();
[download]

Now, for instance, 'coal' appears in the %words dictionary under the key 'aclo'. We can construct the regex /a.*c.*l.*o/. If 'acilnoot' matches, then 'location' contains 'coal'.

for (keys %matches) {
    my $ordered = join '', sort split //;
    $matches{$_} = [ grep {
        length($ordered) < length($_)
        ? 0
        : do {
            my $re = '^(.*?)'
                   . join('(.*)', map {quotemeta} split '')
                   . '(.*)$';
            $ordered =~ /$re/;
        };
    } keys %words];
}
[download]

Finally, print results just to have something to show for all that.

print $_,
      ' contains ',
      "@{[map {@$_} @words{@{$matches{$_}}}]}",
      $/,
      $/ 
    for keys %matches;
__END__
[download]

Running this on my machine as 'time perl anaword.pl location brevity Zoroaster' prints:

location contains loon octal loot tool Al an at in Io it no on to Acto
+n canto Alton onto alnico lion loin Olin lint toil action into Toni I
+lona Latin colon location Tonio Cain Inca clan coal cant coat lotion 
+lain nail tail anti Tina iota Lac can act cat ail Ali Ian Lao ant Nat
+ tan oat Clint con coo cot loan tonic NATO Clio coil loci coin icon L
+in nil oil lit ion tin Ito cool clot colt lot coon not ton too antic

zoroaster contains Zoroaster as at re et or so to Oz ooze Eros ores Ro
+se sore tore zero toes Azores errs rest zest rotor roost roots arose 
+Erato roaster rears Serra rater Terra aster rates stare tears razors 
+orators sorer store zeros Starr rare rear Ares ears eras sear rate te
+ar Ezra raze east eats sate seat teas rooster resort roster sorter or
+ator are ear era Rae sea ate eat tea oar Sao oat art rat tar sat root
+ soot zoos rots sort ore roe toe Zoe err set arrest rarest raster rat
+ers Sartre starer ersatz roar oars Rosa soar oats Taos arts rats star
+ roars razor Astor roast too zoo Orr rot rooter

brevity contains try be by re et it very rivet bier Brie bite Bert ver
+b byte bevy brevity bet bye rib bit biter Tiber tribe ire tie vie rye
+ yet ivy rite tier tire vier Viet


real    0m8.766s
user    0m7.450s
sys     0m0.070s
[download]

Update: Modified regex to anchor at the ends and not miss unused characters, updated times to the new values.

After Compline,
Zaxo

use strict;
use warnings;
use Algorithm::Permute;
my $p = new Algorithm::Permute([qw(c i o l n a o t)]);
my %seen_permutation;
my $length = 5;

while ( my @res = $p->next) {
    my @tmp = @res[0..$length - 1];            #get first n letters of
+ @res;
    my $key = join('',sort {$a cmp $b} @tmp);  #return asciibetical li
+st as key;

    unless ( $seen_permutation{$key} )     #skip if this pattern has b
+een seen before
    {
        $seen_permutation{$key} = 1;
        my $r = new Algorithm::Permute([@tmp]);
        while ( my @sml = $r->next ) {
          print join ('',@sml), $/;
        }
    }
}
[download]

-enlil

HTH, --traveler

Psudocode:

If word is Lenght you are looking for 
if no skip word,
If yest then
check to see if all of the chars in word are in the input array 
If yes you have a hit
next word.
[download]

$_=shift||"ciolnaot";
my $s = join'?',(sort split//),"";
while( <> ){
    chomp;
    next unless length == 4;
    my $t=join'',sort split//;
    print "$_\n" if $t=~/^$s$/;
}
[download]

Don't know of a module, but if you are just looking at strings, the following code would work, printing each generated possibility only once:

#
# Assumes $word and $desired_length previously defined.
#
my @characters = split('', $word);
my (%found);
&gen_nofm(\@characters, \%found, '', $desired_length);
print($_, "\n")    
  foreach (sort({lc($a) cmp lc($b)} keys(%found)));

sub gen_nofm 
{
    my ($charlist, 
      $found_thusly, 
      $partial_word, 
      $desired_length) = @_;
    if ($desired_length) 
    {
        for (my $index = 0; 
          $index < scalar(@{$charlist}); 
          $index++) 
        {
            &gen_nofm($charlist, 
              $found_thusly, 
              $partial_word . ${$charlist}[$index], 
              $desired_length - 1);
        }
    }
    else 
    {
        ${$found_thusly}{$partial_word}++;
    }
}
[download]