However, the values are not being passed back to the Template. Or, if they are, they are not getting displayed.

Here is an SSCCE to demonstrate looping over the return values:

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

sub baz {
    return qw/there World/;
}

my $v = {
    bar => \&baz
};

my $t = join '', <DATA>;

Template->new->process (\$t, $v);

__DATA__
[% FOREACH foo IN bar() %]
Hello [% foo %]!
[% END %]
[download]

Thanks hippo.
Based on your code sample and what I already have, I have built a test which shows it is not the way I am using Template that is the issue - it is my display() function. In the 'real' code this is abstracted into a Site::HTML module because I want to hide the site variables away in a separate module with only Site::HTML and Site::Common having access to it - perhaps I need to rethink that design.

use Template;
use strict;

my $template = Template->new;

my $vars = {
    'frames' => \&get_frames
};

$template->process('test.tt', $vars);   # this works
display('test', $vars);                 # this doesn't

sub get_frames {
    my @list;
    foreach my $l( qw/first second/ ) {
        my $fr = {
            'one' => $l,
            'two' => $l,
        };
        push @list, $fr;
    }
    return @list;
}

sub display {
#    my $self = shift;
    my $file = shift;
    my %vars = @_;
    $template->process("$file.tt", \%vars);
}
[download]

update

The test Template...

Start test...

[% FOREACH frame IN frames() %]
    Frame - [% frame.one %] [% frame.two %]
[% END %]

End test...
[download]

You are passing a hash reference:

display('test', $vars);
[download]

... but you are expecting a "hash" (well, list of pairs):

sub display {
#    my $self = shift;
    my $file = shift;
    my %vars = @_;
[download]

Most likely in display, you want instead:

sub display {
    my( $file, $vars ) = @_;
    $template->process("$file.tt", $vars);
}
[download]

Does this journey tell you anything about the advisability of mixing presentation and code in this fashion? This sort of popping back and forth between presentation and code makes for maintenance headaches. It's also a great temptation with Template Toolkit. For something simple like populating a list with HTML::Template you can:

use strict;
use warnings;
use HTML::Template;

my @items = map {{item => $_}} qw(first second third fourth);
my $template = HTML::Template->new(filehandle => *DATA);

$template->param(items => \@items);
print $template->output();

__DATA__
    <TMPL_IF name="items">
    <ul><TMPL_LOOP name="items">
       <li><TMPL_VAR name="item"></li></TMPL_LOOP>
    </ul></TMPL_IF>
[download]

Prints:

    
    <ul>
       <li>first</li>
       <li>second</li>
       <li>third</li>
       <li>fourth</li>
    </ul>
[download]

and renders as:

• first
• second
• third
• fourth

Does this journey tell you anything about the advisability of mixing presentation and code in this fashion?

Mixing presentation and code is exactly what I am trying to avoid.
The 'real' code will have multiple values pulled from the backend DB, not just one value which is why I put them in an anonymous hash. Having said that, for this part of the code at least, the values will be static in the sense that they won't change during the runtime so having Template call a function won't be necessary.

I think perhaps I need to do some more studying of the different kinds of loop that Template offers. Already I have changed quite a bit of what I have written so that one template file includes another instead of having the code process each separately...so much to learn!