The first example is not emergent behavior. And it has nothing at all to do with the implicit nature of interfaces. It is in fact a pretty straightforward consequence of the fact that functions are first-class types. Because they're types, you can newtype them, and you can implement interfaces on the newtype. This should work in any language that has interfaces and first-class functions.

For reference, here's the exact same thing in Rust:

    // Define trait Foo, this is the equivalent of an interface
    pub trait Foo {
        fn foo(&self, x: int) -> int;
    }

    // Define a newtype called FooFunc
    pub struct FooFunc(fn(x:int) -> int);

    // Explicitly implement the trait on FooFunc
    impl Foo for FooFunc {
        fn foo(&self, x: int) -> int {
            let &FooFunc(f) = self; // unwrap the newtype
            f(x)
        }
    }

    // This is a method that uses a Foo, analogous to http.Handle()
    pub fn doFoo<T: Foo>(f: T) {
        println!("foo(42) = {}", f.foo(42));
    }

    // Here's our function that we want to wrap
    fn MyFoo(x: int) -> int {
        x+1
    }

    fn main() {
        // Call the function, just like http.Handle using http.HandlerFunc
        doFoo(FooFunc(MyFoo));
    }

And just like Go, this ends up being free at runtime.