My solution for this is usually to define methods in the root class that return the names of the aux classes.
In the base class (Thingy), these would return 'Thingy::Cog', 'Thingy::Handle', etc.
In the derived class (MyThingy), these would return 'MyThingy::Cog', 'MyThingy::Handle', etc.
In that way, the differences between the base and the derived classes are kept minimal and isolated.
When the Thingy method that creates a cog object gets called, it refers to the above method to get the name of the class to instantiate.

Of course, this technique requires that the interfaces to the constructors in the base and derived aux classes are kept strictly compatible.

package Thingy;
sub cog_class { 'Thingy::Cog' }
sub get_cog { my $self = shift; $self->cog_class->new(@_) }

package MyThingy;
use base Thingy;
sub cog_class { 'MyThingy::Cog' }
[download]

(It should not be necessary to re-define these name-returning methods in any of the other classes, even if you have, for example, a Cog creating a Ramp, because the cog object should have a reference to the relevant Thingy object, so it can get the name from that, if necessary.)

package MyThingy::Cog;
sub get_ramp { my $self = shift; $self->thingy->ramp_class->new(@_) }
[download]

The following snippets allow you to create objects of the right class. You did not ask for this, but I'm missing the point of creating classes automatically. What is the good of having two identical classes? Answer me this, and I'll answer your original question. (In fact, I've already written the answer.)

package Thingy;
sub make_cog {
   my $self = shift;
   return Cog->new(@_);
}

{
   ...
   my $cog = $self->make_cog(...);
   ...
}

package MyThingy;
sub make_cog {
   my $self = shift;
   return MyCog->new(@_);
}
[download]

or (less recommended)

package Thingy;
sub make_cog {
   my $self = shift;
   my $cog_class = ref($self) . '::Cog';
   if ($cog_class->can('new')) {
      return $cog_class->new(@_);
   } else {
      return Thingy::Cog->new(@_);
   }
}
[download]

Update: Reguarding your update which greatly clarified things, the second snippet should do the trick.

It's really unclear what you want to accomplish. It sounds like you want to subclass the root of an inheritance three and auto-generate the rest of the inheritance accordingly -- but then you're in a multiple inheritance situation, right? Do you mean @MyThingy::Handle::ISA = qw( MyThingy Thingy::Handle )?

I suppose this could be done just with @ISA munging, though it's ugly:

[Original code deleted; see update below]
[download]

Update for japhy's update: Ah! Makes much more sense. How about something along these lines:

sub get_cog {
  my ($self) = @_;
  my $class = ref $self;

  if ( $class eq "Thingy" ) {
    return Thingy::Cog->new;
  }
  else {
    my $cog_class = "$class\::Cog";
    (my $cog_class_file = $cog_class . "pm") =~ s{::}{/};

    if ( grep { -e $_ } map { $_/$cog_class_file } @INC ) {
      require $cog_class_file;
      return $cog_class->new;
    }
    else {
      return Thingy::Cog->new;
    }
  }
}
[download]

Are you sure you need those other classes generated? It sounds wrong to me. Since you're going to auto-generate them, it seems that the X::Cog, etc., classes would all have the same interface to the X:: class as Thingy::Cog does to Thingy. So it seems to me that you can subclass Thingy without having to change the behaviour of X::Cog, et. al.

Can you give a bit more detail so I can see what you're after?

--roboticus