Your module might look something like this:

package MyConst;

use warnings;
use strict;

use base 'Exporter';
use vars qw(@EXPORT_OK %EXPORT_TAGS);
@EXPORT_OK = qw($const1);
%EXPORT_TAGS = (all => \@EXPORT_OK);

# ...
[download]

And the module using it would begin like this:

use MyConst qw(:all);
[download]

It took me a while but I finally got something that works as you want:

##### MyConst.pm #####
package MyConst;

use warnings;
use strict;

use Readonly ();

require Exporter;
our @ISA = qw(Exporter);
our @EXPORT = qw();

Readonly::Scalar our $const1 => 1;
Readonly::Array  our @array  => qw(x y z);
Readonly::Hash   our %hash   => (abc => 123, def => 456);

sub foo { 'foobar' }

my $package = __PACKAGE__;

no strict 'refs';
while (my $sym = each %{ "$package\::" }) {
    # skip internals
    next if $sym =~ /^(?:BEGIN|EXPORT|ISA)$/;

    if (defined ${ $sym }) {
        push @EXPORT, "\$$sym";
    }
    elsif (defined %{ $sym }) {
        push @EXPORT, "\%$sym";
    }
    elsif (defined @{ $sym }) {
        push @EXPORT, "\@$sym";
    }
    elsif (defined &{ $sym }) {
        push @EXPORT, "$sym";
    }
}

1;
__END__
[download]

Note 1: the position of our combined with Readonly is tricky. Using our Readonly::Scalar $const1 => 1 instead won't export $const1, but won't complain either.

Note 2: be careful to not import any other symbols from other modules (e.g. Data::Dumper exports Dumper by default).

##### test.pl #####
# Uncomment to see Exporter's magic
#BEGIN { $Exporter::Verbose = 1 }

use MyConst;
use Data::Dumper ();

use strict;
use warnings;

print Data::Dumper->Dump([$const1, \@array, \%hash], [qw(*const1 *arra
+y *hash)]), "\n";
print 'foo() = ', foo(), "\n";
__END__
[download]

Thanks to Abigail's code referenced by zentara on Re: Listing the functions of a package / methods of an object.

Update: There's a simpler method, which is to export a hash and make everything to be exported a member of that hash, so there's only 1 element to export.