They basically copied the concept of arrays from Java in C# 1.0. Generics did not exist at the time, but the developers believed they were clever and replicated the Java arrays' faulty covariant array semantics. This implies that you can do things like this without getting a compile-time error (rather than a runtime error):
Mammoth mammoths = new Mammoth;
Animal animals = mammoths; // Covariant conversion
animals = new Giraffe(); // Run-time exception
Generics were introduced in C# 2.0, although there were no covariant/contravariant generic types. If arrays were made generic, you wouldn't be able to cast Mammoth to Animal, which was previously possible (even though it was broken). As a result, making arrays generic would have caused a lot of code to break.
Covariant/contravariant generic types for interfaces were introduced in C# 4.0. This allowed the array covariance to be fixed once and for all. However, this would have caused a lot of current code to break.
Array<Mammoth> mammoths = new Array<Mammoth>(10);
Array<Animal> animals = mammoths; // Not allowed.
IEnumerable<Animals> animals = mammoths; // Covariant conversion
Compatibility. Array is a legacy type that dates back to a time when generics were not available.
Today, it would be more logical to have Array first, then Array<T>, and finally the specific class.