What looks most suspicious to me (and perhaps to kcott), are the '&' sigils in your use and %EXPORT_TAGS.

The ampersand is optional, but legal in the exporter variables (@EXPORT and @EXPORT_OK). Quoting Exporter:

How to Export

The arrays @EXPORT and @EXPORT_OK in a module hold lists of symbols that are going to be exported into the users name space by default, or which they can request to be exported, respectively. The symbols can represent functions, scalars, arrays, hashes, or typeglobs. The symbols must be given by full name with the exception that the ampersand in front of a function is optional, e.g.

        @EXPORT    = qw(afunc $scalar @array);   # afunc is a function
        @EXPORT_OK = qw(&bfunc %hash *typeglob); # explicit prefix on 
+&bfunc
[download]

If you are only exporting function names it is recommended to omit the ampersand, as the implementation is faster this way.

From that, I conclude that the ampersand is optional, but not recommended also in %EXPORT_TAGS and in parameters for import() (i.e. after use and require).

The source code of Exporter actively removes leading ampersands in sub import:

  my $exports = \@{"$pkg\::EXPORT"};
  # ...
  my $export_cache = ($Cache{$pkg} ||= {});
  my $args = @_ or @_ = @$exports;

  if ($args and not %$export_cache) {
    s/^&//, $export_cache->{$_} = 1
      foreach (@$exports, @{"$pkg\::EXPORT_OK"});
  }
[download]

The same logic also exists in Exporter::Heavy:

sub _rebuild_cache {
    my ($pkg, $exports, $cache) = @_;
    s/^&// foreach @$exports;
    @{$cache}{@$exports} = (1) x @$exports;
    my $ok = \@{"${pkg}::EXPORT_OK"};
    if (@$ok) {
    s/^&// foreach @$ok;
    @{$cache}{@$ok} = (1) x @$ok;
    }
}
[download]

Exporter::Heavy even adds ampersand prefixes sometimes:

sub heavy_export {
    # ...
    my($pkg, $callpkg, @imports) = @_;
    my($type, $sym, $cache_is_current, $oops);
    my($exports, $export_cache) = (\@{"${pkg}::EXPORT"},
                                   $Exporter::Cache{$pkg} ||= {});

    # ...

    my($fail, $fail_cache) = (\@{"${pkg}::EXPORT_FAIL"},
                              $Exporter::FailCache{$pkg} ||= {});

    if (@$fail) {
    if (!%$fail_cache) {
        # Build cache of symbols. Optimise the lookup by adding
        # barewords twice... both with and without a leading &.
        # (Technique could be applied to $export_cache at cost of memo
+ry)
        my @expanded = map { /^\w/ ? ($_, '&'.$_) : $_ } @$fail;
        warn "${pkg}::EXPORT_FAIL cached: @expanded" if $Exporter::Ver
+bose;
        @{$fail_cache}{@expanded} = (1) x @expanded;
    }
    my @failed;
        # ...
    }

    # ...
}
[download]

Alexander