Rather than hardcoding the fallback into the class itself, why not implement a dispatcher object, which, given the current class (available through caller()) and the kind of failure (?) does a lookup to determine the next class to try, to wit:

my %FSM = ( First => { fail_a => 'Second',
                       fail_b => 'Third',
                       pass   => undef },  # we're done
            Second =>{ fail_c => 'Third',
                       pass   => undef ) );
[download]

Rather like a sparse-matrix.

Then the code within any of the classes 'First', "Second' or 'Third' would merely consult the %FSM hash for what to do next. This brings up the problem of how (where?) to scope the %FSM hash. This should probably be a member within a common base-class:

package Base;

sub new {
    my $class = shift;
    my $self = { FSM => {First => { fail_a => 'Second',
                                    fail_b => 'Third',
                                    pass   => undef },  # we're done
                         Second =>{ fail_c => 'Third',
                                    pass   => undef )} };
    bless $self, $class;
    return $self;
}

package First;
use base qw( Base );

sub new {
  # ...
}

package Second;
use base qw( Base );

sub new {
  # ...
}

# ... and so on
[download]

Any of the derived classes could access it as $self->{FSM}.

dmm