One problem is that using delete on arrays leave behind an undef 'placeholder' which mean your scalar @$ref test fails, hence the undef in your result. The fix is to use splice for arrays.

I've always like dispatch tables for this kind of mutual recursion:

#!/usr/bin/perl -w
use strict;
use Data::Dumper;

my %dispatch = (
    SCALAR => sub{ return 1; },
    ARRAY  => sub {
        my $ref = shift;
        clean( $ref->[ $_ ] )
            or splice @$ref, $_, 1
            for reverse 0 .. $#$ref;
        return 0 unless @$ref;
    },
    HASH  => sub {
        my $ref = shift;
        my( $key, $val);
        clean( $val )
            or delete $ref->{ $key }
            while ( $key, $val ) = each %$ref;
        return 0 unless scalar keys %$ref;
    },
    REF  => sub{ my $ref = shift; die "REF: $ref not allowed"; },
    CODE => sub{ my $ref = shift; die "CODE: $ref not allowed"; },
    ''  => sub{ return 1; },
);

sub clean { return $dispatch{ ref $_[0] }->( $_[0] ); }

my @array = (
    [1],
    [],
    { 1 => 2, 2 =>{} }
);

clean(\@array);

print Dumper(\@array);

__END__
$VAR1 = [
          [
            1
          ],
          {
            '1' => 2
          }
        ];
[download]