Is there a built-in function to map a list of heads to a list of data?

Update

Well I guess I should retire for the evening to a less brain-intensive activity as apparently I can't think clearly. One could of course use Outer:

Outer[Compose, {f, g}, {a, b, c}]

{{f[a], f[b], f[c]}, {g[a], g[b], g[c]}}

However I recommend that you do not do this as you will not gain the auto-compilation of Map, meaning this method will often be slower. Please see Leonid's explanation of this issue.

Old, half-awake answer

As far as I can remember there is no function that does specifically this in one step. I have used a more terse version of your own solution myself:

myMap[fns_, data_] := # /@ data & /@ fns

myMap[{f, g}, {a, b, c}]

{{f[a], f[b], f[c]}, {g[a], g[b], g[c]}}

There are of course many alternatives, e.g.:

Thread /@ Through[{f, g}[{a, b, c}]]

{{f[a], f[b], f[c]}, {g[a], g[b], g[c]}}

However this inferior because it first evaluates to:

{f[{a, b, c}], g[{a, b, c}]}

Which means that f and g may evaluate before the operation is complete. One could add an Unevaluated, Hold, Inactive etc., but that seems like pointless complexity.

Just for fun we could make use of the operator form of Map in version 10:

Through[(Map /@ {f, g})[{a, b, c}]]

{{f[a], f[b], f[c]}, {g[a], g[b], g[c]}}

I don't think there's any built-in function to do this, but here is an alternative:

myFunc[func_, data_] := Transpose[Through[func[#]] & /@ data]

Then

myFunc[{f, g, h}, {a, b, c}]

{{f[a], f[b], f[c]}, {g[a], g[b], g[c]}, {h[a], h[b], h[c]}}

Outer[#1 @ #2 &, {f, g}, {a, b, c}] or Outer[Construct, {f, g}, {a, b, c}] can do.