I suspect that it has something to do with {} being a reference to another, newly created value. Let's break things down.

my %a : shared = ();
$a{foo} = {};
$a{bar} = 42;
[download]

What I suspect to be happening here, is the following.

The first line conveniently reads from left to right: my %a declares the hash in the current lexical scope in the current thread. : shared shares the hash with all other threads. = (); assigns the empty list to this hash.

The next line has most of its action on the far right side. {}; creates an anonymous hash in the current thread. Due to being anonymous, it's not bound by any scope — it will simply live for as long as something references to it. So {} is kind enough to create and return that reference. That's right: a reference and the value it refers to, are in fact not the same entity. $a{foo} = then stores that reference under the key "foo" in the hash %a.

If you want, you can see that {} creates a new value:

print {}, "\n";
print {}, "\n";
[download]

And the last line simply stores the number 42 in $a{bar}. There is no referencing here, and no creation of a new value. 42 will be 42, so there's no need to share it here.

So my best guess, the reason you need to &share( {} ) is not because $a{foo} isn't shared, but because the anonymous hash that {} created, isn't shared.