How does embedding propagate interface satisfaction through multiple levels?

type Named interface { Name() string }
type Described interface { Describe() string }
type NamedAndDescribed interface { Named; Described }

// Level 1
type Animal struct{ name string }
func (a Animal) Name() string { return a.name }

// Level 2 — embeds Animal
type Pet struct {
    Animal
    Owner string
}
func (p Pet) Describe() string {
    return fmt.Sprintf("%s owned by %s", p.Name(), p.Owner)
}

// Level 3 — embeds Pet
type ServiceAnimal struct {
    Pet
    BadgeID string
}
// ServiceAnimal inherits Name() from Animal (via Pet) and
// Describe() from Pet

sa := ServiceAnimal{
    Pet: Pet{
        Animal: Animal{name: "Rex"},
        Owner:  "Alice",
    },
    BadgeID: "K9-042",
}

var nd NamedAndDescribed = sa // ServiceAnimal satisfies NamedAndDescribed
fmt.Println(nd.Name())        // Rex
fmt.Println(nd.Describe())    // Rex owned by Alice

// Method ambiguity: what if both A and B define the same method?
type X struct { Val int }; func (x X) Tag() string { return "X" }
type Y struct { Val int }; func (y Y) Tag() string { return "Y" }

type Ambiguous struct { X; Y }
// a := Ambiguous{}; a.Tag() // COMPILE ERROR: ambiguous selector a.Tag
// Must qualify: a.X.Tag() or a.Y.Tag()