The OP is asking why the first match is returned by $&. Even with /g the first match is returned because it is not in list context.

#!/usr/bin/perl
use warnings;
use strict;

"AAC\nGTT"=~/^.*$/mg;
print "\$& scalar context => $&\n";

my @matches = "AAC\nGTT"=~/^.*$/mg;
print "\$&   list context => $&\n";
print "\@matches => @matches\n";

__END__

output:
$& scalar context => AAC
$&   list context => GTT
@matches => AAC GTT
[download]

'g' is not restricted to list context. If you use a regex on a specific variable multiple times with the 'g' modifier you will get all the matches one by one.

For 'g' to work in scalar context you need to search multiple times. AND you have to search the same variable, because the variable remembers the location up to which it searched last. Or use an array and list context:

Scalar usage:

#scalar usage:
my $x="AAC\nGTT";
my $i=0;
while ($x=~/^.*$/mg) {
    print $&; 
}

#or do the loop by foot if you know how many times it will match:

my $x="AAC\nGTT";
$x=~/^.*$/mg;
print $&;
$x=~/^.*$/mg;
print $&;
[download]

or use the regex in list context:

my $x="AAC\nGTT";

my @allhits= $x=~/^.*$/mg;
print join(" - ", @allhits),"\n";
[download]

Note: This would have served better as a reply to Re^2: /m pattern matching modifier, which first mentions the  "\nGTT\n" string.

The regex  /^.*$/mg matches the empty string (not 'nothing', i.e., no match) in the string  "\nGTT\n" because the /m regex modifier causes ^ to match at the start of a string (the default) and also immediately after an embedded newline, and causes $ to match its default and also just before an embedded newline.

A regex looks for the leftmost match. The leftmost position in the string above that matches the regex above is ^ (the absolute start of the string), .* (zero of any character except a newline), and $ (just before the first newline), and the string that exists at this position is the empty string.

Regexes are often counter-intuitive!

Updates:

1. And, as jethro said, even with the /g modifier, the regex matching in void or scalar context will still only return the leftmost of all possible matches on the first match attempt.
2. s/place/position/g, s/just before a newline/just before the first newline/ in the foregoing text.