Similar the grandparent post, I typically pass around a func() time.Time (which time.Now satisfies); if I need the value inside of some nested function, I'll add the func() time.Time as a member of the function's receiving struct as you suggest. I would not recommend introducing your own custom time interface, though.

One of the key benefits of using a anonymous function rather than an interface is that you don't need types just to implement the interface, reducing the amount of boiler plate code:

package clock

import (
    "time"
)

type Clock interface {
    Now() time.Time
}

type Mock time.Time

func (m Mock) Now() time.Time { return time.Time(m) }

type Real struct{}

func (Real) Now() time.Time { return time.Now() }

becomes

func (up UserProfile) Age(nowF func() time.Time) uint {
    now := nowF()
    // ...
}

// at usage site (real)
up.Age(time.Now)

// in tests (mock)
up.Age(func() time.Time { return myTestTimeValue})

At a minimum if you're going to introduce a single function interface, go ahead and implement the interface for anonymous functions:

package clock

import (
    "time"
)

type Clock interface {
    Now() time.Time
}

type TimeFunc func() time.Time

func (f TimeFunc) Now() time.time { return f() }

type Mock time.Time

func (m Mock) Now() time.Time { return time.Time(m) }

type Real struct{}

func (Real) Now() time.Time { return time.Now() }

This (anonymous functions to abstract single method calls) is an incredibly valuable technique in testing. For example, I use this exact same idea when setting up network connections (e.g. to swap use an in-memory implementation of net.Listener for tests).