Reason for certain restrictions on variance conversions in C#

Question

I have a few questions about the way implicit conversions between method delegates with regards to covariance and contravariance are implemented in C#.

delegate void ImplicitFunction<T>(T thing);
delegate void ExplicitFunction<in T>(T thing);
delegate void AnimalFunction(Animal thing);
delegate void DogFunction(Dog thing);

static void Process<T>(T thing) {
    // ...
}
static void AnimalProcess(Animal thing) {
    // ...
}

static void Main() {

From my understanding, variance handling is implicit with regards to assigning a function to a non-identical delegate, i.e.:

    ImplicitFunction<Dog> processObject = Process<Animal>;

(Conceptually, although possibly not semantically, I believe this is contravariance. Of course, if any of my assumptions are completely wrong, I would appreciate a correction.) After many hours of careful studying, I believe I completely understand how this works and why. But I have also learned that I cannot convert a method from one type (delegate) to another, even though it is assigning the same value to the same type, just in two steps:

    ImplicitFunction<Animal> tempProcessor = Process<Animal>;
    ImplicitFunction<Dog> processDogConv = tempProcessor; // compile error

Question 1: why not? And please do not say, "because you do not use 'in'" or "because it is not a generic type". I would like to know what the justification is for this behavior, in the same way that variance restrictions are in place to prevent passing invalid types in certain cases. Now, I have also learned that C# supports explicit delegate conversion using the keywords 'in' and 'out'. Like so:

    ExplicitFunction<Animal> processAnimal = Process<Animal>;
    ExplicitFunction<Dog> processDog = processAnimal;

But I can't do the same thing without generics:

    AnimalFunction processAnimalNonGeneric = AnimalProcess;
    DogFunction processDogNonGeneric = processAnimalNonGeneric; // compile error

I have a feeling the reason for this may be closely related to the reason that implicit variance conversions are not supported.

Question 2: But why? Why can't I use the 'in' keyword something like so:

delegate void AnimalFunction(in Animal thing);
delegate void DogFunction(in Dog thing);

Once again, I know that just isn't how it works, but what is the theoretical, "we-can't-because-what-if-someone-did-this" reason for excluding this functionality?

}

P.S. This code has been compiled to make sure it behaves as I describe, and all that is needed is a wrapper class and two empty Dog : Animal classes.