How do I recursively search a JSON file for all nodes matching a given pattern and return the JSON 'path' to the node and it's value?

Once that JSON is decoded, there is a complex (nested) Perl data structure that you want to search through, and the code you show is honestly aiming for that.

However, there are libraries out there which can help; either to do the job fully or to provide complete, working, and tested code that you can fine tune to the exact needs.

The module Data::Leaf::Walker seems suitable. A simple example

use warnings;
use strict;
use feature 'say';

use Data::Dump qw(dd);
use JSON;
use List::Util qw(any);

use Data::Leaf::Walker;

my $file = shift // 'data.json';                       # provided data sample

my $json_data = do { local (@ARGV, $/) = $file; <> };  # read into a string
chomp $json_data;

my $ds = decode_json $json_data;
dd $ds; say '';                   # show decoded data
    
my $walker = Data::Leaf::Walker->new($ds);

my $sep = '->';
while ( my ($key_path, $value) = $walker->each ) { 
    my @keys_in_path = @$key_path;
    if (any { $_ eq 'name' } @keys_in_path) {          # selection criteria
        say join($sep, @keys_in_path), " => $value" 
    }   
}

This 'walker' goes through the data structure, keeping the list of keys to each leaf. This is what makes this module particularly suitable for your quest, along with its simplicity of purpose in comparison to many others. See documentation.

The above prints, for the sample data provided in the question

widget->window->name => main_window
widget->text->name => text1
widget->image->name => sun1

The implementation of the criterion for which key-paths get selected in the code above is rather simple-minded, since it checks for 'name' anywhere in the path, once, and then prints the whole path. While the question doesn't specify what to do about matches earlier in the path, or with multiple ones, this can be adjusted since we always have the full path.

The rest of your wish list is fairly straightforward to implement as well. Peruse List::Util and List::MoreUtils for help with array analysis.

Another module, that is a great starting point for possible specific needs, is Data::Traverse. It is particularly simple, at 70-odd lines of code, so very easy to customize.

Depending on your task, you might consider using jq. This output is simple, but you can get as complex as you like:

$ jq -r '.. | .image? | .src | strings'  test.json
Images/Sun.png
$ jq -r '.. | .name? | strings'  test.json
main_window
sun1
text1

Walking the data structure isn't that bad, although it's a bit weird the first couple of times you do it. There are various modules on CPAN that will do for you (as zdim shows), but this is something you should probably know how to do on your own. We have some big examples in Intermediate Perl.

One way to do it is to start with a queue of things to process. This is iteration, not recursion, and depending on how you add elements to the queue, you can do either depth-first or breadth-first searches.

For each item, I'll track the path of keys to get there, and the sub-hash. That's the problem with your recursive approach: you don't allow for a way to track the path.

At the start, the queue has one item because we are at the top. I'll also define a target key, since your problem has that:

my @queue = ( { key_path => [], node => $hash } );
my $target = 'name';

Next, I process every item in the queue (the while). I expect each value of node to be a hash, so I'll get all the keys of that hash (the foreach). This represents the next level of the hash.

Inside the foreach, I make a new key path with the one that exists along with the one I'm processing. I also get the next value by using that key.

After that, I can do task specific processing. If I've found my target key, I'll do whatever I need to do. In this case I output some stuff, but I could add to a different data structure and so on. I use next to stop processing that key (although I could keep going). If I didn't find the target key, I make another entry in the queue if the value is another hash reference.

Then, I go back to processing the queue.

use v5.24; # use postfix dereferencing

while( my $h = shift @queue ) {
    foreach my $next_key ( keys $h->{node}->%* ) {
        my $key_path = [ $h->{key_path}->@*, $next_key ];
        my $value    = $h->{node}{$next_key};

        if( $next_key eq $target ) {
            say join( "->", $key_path->@* ), " = $value";
            next;
            }
        elsif( ref $value eq ref {} ) {
            push @queue, { key_path => $key_path, node => $value };
            }
        }
    }

I end up with output like:

widget->text->name = text1
widget->image->name = sun1
widget->window->name = main_window

From there, you can customize this to get the other features you need. If you want to find a complex key, you just do a little more work to compare the key path to what you want.