Well spotted, sauoq! There are indeed bugs:

1. There was a bug in the implementation of skeeve2
2. There was a bug in my correction algorithm

sub skeeve2 {
   my %count;

   for my $i (0..length($seq)-GROUP_LENGTH) {
      $count{substr($seq, $i, GROUP_LENGTH)}++;
   }

   my @keys = keys %count;
   foreach my $key (@keys) {
      for my $i (1..GROUP_LENGTH-1) {
         $count{substr($key, 0, $i)} += $count{$key};
      }
   }
   for my $i (1..GROUP_LENGTH-1) {
      for my $j ($i..GROUP_LENGTH-1) {
          ++$count{substr($seq, -$j, $i)};
      }
   }
   1;
}


sub skeeve3 {
   my %count;

   $count{"$1$2"}++ while $seq =~ /(.)(?=(..))/g;

   my @keys = keys %count;
   foreach my $key (@keys) {
      for my $i (1..GROUP_LENGTH-1) {
         $count{substr($key, 0, $i)} += $count{$key};
      }
   }
   for my $i (1..GROUP_LENGTH-1) {
      for my $j ($i..GROUP_LENGTH-1) {
          ++$count{substr($seq, -$j, $i)};
      }
   }

   1;
}


sub skeeve3_i {
   my %count;

   $count{$1}++ while $seq =~ /(?=(.{3}))/g;

   my @keys = keys %count;
   foreach my $key (@keys) {
      for my $i (1..GROUP_LENGTH-1) {
         $count{substr($key, 0, $i)} += $count{$key};
      }
   }
   for my $i (1..GROUP_LENGTH-1) {
      for my $j ($i..GROUP_LENGTH-1) {
          ++$count{substr($seq, -$j, $i)};
      }
   }

   1;
}
[download]

I'll fix my algorithm outlined in my other post.

Regarding your other issues:

1. including the file reads in your benchmark obscures the issue. As long as the machine has plenty of memory (and maybe yours doesn't) you are contaminating your results with two different methods of reading the data.
   
   I don't agree. It was intended that way.
   
   Reading chunks of data is important if you are low on memory. And I'm 100% sure the OP has to read his data from a file. So reading data is something that is essential for the algorithm.
   
   
2. you could modify my algorithm and most of the others' to work with chunks as well if RAM really was an issue.
   
   Here I do agree. Of course can it be done. But you didn't ;-)
   
   I challenge you to do so and then let's compare times.
   
   But OTOH: My algorithm taking low memory into account is the same as a2, the one ikegami implemented as "skeeve2". So the only difference should be the time needed for reading of data. And if we all do so, and if we all read the same chunk-size, there shouldn't be a difference in the ranking.
   
   Of course: All of you could rewrite and use my correction algorithm. This would make some of your algorithms significantly faster, I think.