Exercise 1: loadProfile() Using async let for Parallel Fetches — Possible Solution
=========================================================================================

func fetchUserName() async -> String {
    // imagine a real network call happens here
    return "Alex"
}

func fetchAvatarURL() async -> String {
    // imagine a real network call happens here
    return "https://example.com/avatar.png"
}

func loadProfile() async -> (name: String, avatarURL: String) {
    async let name = fetchUserName()
    async let avatarURL = fetchAvatarURL()

    return await (name, avatarURL)
}

HOW IT WORKS: Both async let declarations start their own real
asynchronous work immediately, at the moment each line executes - not
sequentially, and not waiting for one to finish before starting the
other. The actual, real suspension only happens once await (name, avatarURL)
is reached, which pauses loadProfile() until BOTH child operations
have completed, then bundles their two results into a single real
tuple.

This is genuinely different from writing:

let name = await fetchUserName()
let avatarURL = await fetchAvatarURL()

which would run strictly sequentially - the second call wouldn't even
start until the first had fully finished. With async let, both real
network calls (in a genuine implementation) would be in flight
simultaneously, and the overall real time loadProfile() takes is
determined by whichever of the two takes longer, not by their combined
total time.

ANSWER: async let name = fetchUserName() and
async let avatarURL = fetchAvatarURL() both start immediately and run
in parallel, with await (name, avatarURL) suspending only once, until
both real results are ready - correctly implementing parallel,
structured concurrency rather than two sequential awaits.

WHY THIS WORKS AS AN ANSWER
------------------------------
This correctly uses async let to start two independent async
operations in parallel and combines their results with a single await,
exactly matching the chapter's own loadDashboard() pattern applied to
a new, genuinely parallel real-world case.