use Module::List::Pluggable qw(list_modules_under);
use Data::Dumper;
print Dumper(list_modules_under("DBD"));
[download]

It would be possible to traverse each element of @INC, but that strikes me as rather ugly.

It is ugly, and it's not enough. With that approach you get all parent classes, not all subclasses. Instead you'd have to walk the symbol tables and check their @ISA arrays - even uglier.

Generally it's better to use a different approach, for example register each base class with the parent:

{
   package Your::Parser;

   my @parsers;

   sub register {
      push @parsers, $_[0];
   }
}
{
   package Your::Sub::Parser;
   our @ISA qw(Your::Parser);
   __PACKAGE__->register();
}
[download]

Actually you'd want to walk the symbol table looking for @ISA in various packages which refer back (directly or indirectly) to your superclass, not @INC. But it sounds like you're trying to do an abstract factory pattern, in which case a cleaner mechanism would be to provide a callback in the top level factory package which implementing subclasses call to register themselves (e.g. in your MyLogFactory::Parser::Foo module it calls MyLogFactory->registerParser( 'Foo' => 'MyLogFactory::Parser::Foo' );, which then makes MyLogFactory->parserFor( 'Foo' ) return an instance of MyLogFactory::Parser::Foo).

(Granted in perl you could have my $parserClass = 'MyLogFactory::Parser::Foo' and $parserClass->new straight in the calling code and would work too . . .; unlike (say) C++ you don't need to register a hard pointer to the constructor since the client code can dynamically instantiate itself with just the package name :)

Update: tweaked trailing parenthetical's wording to clarify.

You can have the child classes register themselves with the superclass. One easy way to do this is via the superclass'es import subroutine, which is triggered by use.

See my recent node Re^2: How not to hardcode a package name? for an example.

If your subclasses are already loaded, then you can use Class::CanBeA to identify which ones are subclasses of a given class.

Simply looking at filenames in @INC ain't gonna do the job right in general. For example, it might tell you that Class::DBI::ClassGenerator is a subclass of Class::DBI when it isn't - it even contains the test "use base 'Class::DBI'" just to confuse matters.