This is my solution (available in the Go Playground here — I've written code from the Fetch struct to the Crawl function, the rest was already provided by the exercise):

package main

import (
    "fmt"
    "sync"
    "time"
    "math/rand"
)

type Fetcher interface {
    Fetch(url string) (body string, urls []string, err error)
}

type Fetch struct {
    url   string
    depth int
}

type Cache struct {
    visited map[string]bool
    mux     sync.Mutex
}

func (c *Cache) onMissDoAsync(s string, f func()) {
    c.mux.Lock()
    defer c.mux.Unlock()
    if !c.visited[s] {
        c.visited[s] = true
        go f()
    }
}

func NewAsyncCrawler(fetcher Fetcher, timeout time.Duration) (crawl func(Fetch)) {
    results := make(chan Fetch)
    cache := Cache{visited:make(map[string]bool)}
    crawl = func(fetch Fetch) {
        if fetch.depth <= 0 {
            return
        }
        cache.onMissDoAsync(fetch.url, func() {
            body, urls, err := fetcher.Fetch(fetch.url)
            if err != nil {
                fmt.Println(err)
                return
            }
            fmt.Printf("found: %s %q\n", fetch.url, body)
            if fetch.depth > 1 {
                for _, url := range urls {
                     if !cache.visited[url] {
                        results <- Fetch{url, fetch.depth - 1}
                    }
                }
            }
        })
        select {
        case next := <-results:
            crawl(next)
        case <-time.After(timeout):
            return
        }
    }
    return
}

func Crawl(url string, depth int, fetcher Fetcher) {
    crawl := NewAsyncCrawler(fetcher, 500 * time.Millisecond)
    crawl(Fetch{url, depth})
}

func main() {
    Crawl("http://golang.org/", 4, fetcher)
}

type fakeFetcher map[string]*fakeResult

type fakeResult struct {
    body string
    urls []string
}

func (f fakeFetcher) Fetch(url string) (string, []string, error) {
    rand.Seed(time.Now().UnixNano())
    time.Sleep(time.Duration(rand.Intn(500)) * time.Millisecond)
    if res, ok := f[url]; ok {
        return res.body, res.urls, nil
    }
    return "", nil, fmt.Errorf("not found: %s", url)
}

var fetcher = fakeFetcher{
    "http://golang.org/": &fakeResult{
        "The Go Programming Language",
        []string{
            "http://golang.org/pkg/",
            "http://golang.org/cmd/",
        },
    },
    "http://golang.org/pkg/": &fakeResult{
        "Packages",
        []string{
            "http://golang.org/",
            "http://golang.org/cmd/",
            "http://golang.org/pkg/fmt/",
            "http://golang.org/pkg/os/",
        },
    },
    "http://golang.org/pkg/fmt/": &fakeResult{
        "Package fmt",
        []string{
            "http://golang.org/",
            "http://golang.org/pkg/",
        },
    },
    "http://golang.org/pkg/os/": &fakeResult{
        "Package os",
        []string{
            "http://golang.org/",
            "http://golang.org/pkg/",
        },
    },
}

This is my solution (available in the Go Playground here — I've written code from the Fetch struct to the Crawl function, the rest was already provided by the exercise):

package main

import (
    "fmt"
    "sync"
    "time"
    "math/rand"
)

type Fetcher interface {
    Fetch(url string) (body string, urls []string, err error)
}

type Links struct {
    urls  []string
    depth int
}

type ConcurrentStringSet struct {
    set map[string]bool
    mux     sync.Mutex
}

func (cache *ConcurrentStringSet) onMissDoAsync(s string, f func()) {
    cache.mux.Lock()
    defer cache.mux.Unlock()
    if !cache.set[s] {
        cache.set[s] = true
        go f()
    }
}

func NewAsyncCrawler(fetcher Fetcher, timeout time.Duration) (crawl func(string, int)) {
    links := make(chan Links)
    cache := ConcurrentStringSet{set:make(map[string]bool)}
    crawl = func(url string, depth int) {
        cache.onMissDoAsync(url, func() {
            body, urls, err := fetcher.Fetch(url)
            if err != nil {
                fmt.Println(err)
            } else {
                fmt.Printf("found: %s %q\n", url, body)
                if depth > 1 {
                    links <- Links{urls, depth - 1}
                }
            }
        })
        for { 
            select {
            case link := <-links:
                for _, url := range link.urls {
                    go crawl(url, link.depth)
                }
            case <-time.After(timeout):
                return
            }
        }
    }
    return
}

func Crawl(url string, depth int, fetcher Fetcher) {
    if (depth > 0) {
        crawl := NewAsyncCrawler(fetcher, 500 * time.Millisecond)
        crawl(url, depth)
    }
}

func main() {
    Crawl("http://golang.org/", 4, fetcher)
}

type fakeFetcher map[string]*fakeResult

type fakeResult struct {
    body string
    urls []string
}

func (f fakeFetcher) Fetch(url string) (string, []string, error) {
    rand.Seed(time.Now().UnixNano())
    time.Sleep(time.Duration(rand.Intn(500)) * time.Millisecond)
    if res, ok := f[url]; ok {
        return res.body, res.urls, nil
    }
    return "", nil, fmt.Errorf("not found: %s", url)
}

var fetcher = fakeFetcher{
    "http://golang.org/": &fakeResult{
        "The Go Programming Language",
        []string{
            "http://golang.org/pkg/",
            "http://golang.org/cmd/",
        },
    },
    "http://golang.org/pkg/": &fakeResult{
        "Packages",
        []string{
            "http://golang.org/",
            "http://golang.org/cmd/",
            "http://golang.org/pkg/fmt/",
            "http://golang.org/pkg/os/",
        },
    },
    "http://golang.org/pkg/fmt/": &fakeResult{
        "Package fmt",
        []string{
            "http://golang.org/",
            "http://golang.org/pkg/",
        },
    },
    "http://golang.org/pkg/os/": &fakeResult{
        "Package os",
        []string{
            "http://golang.org/",
            "http://golang.org/pkg/",
        },
    },
}