Pasar parámetros de C# que pueden "encajar" en una interfaz, pero que en realidad no la implementan

Puede usar un objeto dynamic wrapper para cablear esto usted mismo, pero pierde la seguridad de tipo dentro de la clase wrapping:

class GreetableWrapper : IGreetable
{
    private dynamic _wrapped;
    public GreetableWrapper(dynamic wrapped)
    {
        _wrapped = wrapped;
    }

    public string Greet()
    {
        return _wrapped.Greet();
    }
}

static void PrintGreeting(IGreetable g) => Console.WriteLine(g.Greet());
static void Main(string[] args)
{
    PrintGreeting(new GreetableWrapper(new Person()));
    Console.ReadLine();
}

Esto puede ser bastante fácil pronto. Las clases de tipo se pueden introducir en C # como formas donde podrá definir características de una clase y código contra esa forma y luego hacer uso de su código con cualquier tipo que coincida sin que el autor de ese código tenga que declarar nada, más o menos como usted describe.

Lo más cercano en C# ahora es, quizás, cómo foreach funciona con un tipo que tiene un GetEnumerator() devuelve un objeto de un tipo con un MoveNext() y Current incluso ellos no implementan IEnumerable etc. solo mientras que ese es un concepto incorporado con el que el compilador se ocupa, aquí puede definirlos.

Curiosamente, también le permitirá definir miembros estáticos.

No creo que esto sea posible. El compilador necesita ver algo que implemente explícitamente la interfaz o clase para que el compilador pueda confirmar que todo está implementado.

Si pudiera hacerlo usando redirección, podría fallar al implementar algo. Y eso va en contra del enfoque de seguridad adoptado por .NET.

Una opción es crear una clase wrapper sobre la persona y pasar este wrapper al método, el wrapper necesita implementar explícitamente la interfaz.

Si tienes el control del código externo, y estás dispuesto a envolver el objeto (y parece que todas las respuestas aquí envuelven), el enlace dinámico y las bibliotecas como Impromptu-Interface me parecen un montón de problemas para algo que es esencialmente un trazador de líneas.

class GreetablePerson : Person, IGreetable { }

Y ya está.

Cuando el compilador está construyendo la clase GreetablePerson, el método de Person termina haciendo una implementación implícita de la interfaz, y todo "simplemente funciona."El único irritación es que el código exterior tiene que instanciar GreetablePerson objetos, pero en la terminología orientada a objetos estándar, una instancia de GreetablePerson es una instancia de Person, por lo que esto me parece una respuesta válida a la pregunta como se hizo.

Si los requisitos se cambian de tal manera que también tenga instancias preexistentes de Person, entonces algo como Impromptu-Interface puede volverse más tentador, pero incluso entonces es posible que desee considerar dar GreetablePerson un constructor que copie de Person. Elegir el mejor camino a partir de ahí requiere obtener más detalles sobre los requisitos y los detalles de implementación reales de la clase Person en cuestión.

En una especie de no relacionado, esto es algo que se hace comúnmente en otros idiomas, como Scala y Haskell.

Se conoce como usar lo que se llaman "clases de tipo". Las clases de tipo esencialmente le permiten definir el comportamiento de un tipo como si implementara explícitamente una interfaz, sin requerir que lo haga. Puedes leer más al respecto aquí.