Why C# allows that only the last parameter of a method is of "variable length"

Because how would the compiler know when the variable arguments for the first parameter stop?

Pleas tell me what argOne and argTwo should contain inside of the method body:

void Foo( params object[] argOne, params object[] argTwo )
{
    // whatever
} 

Foo( 1, false, "Hello", new object(), 2.3 );

Because it would be too complicated to determine when such a construction is actually allowed.
(When the call would be unambiguous)
Although it would be possible to create a good set of rules, they would be rather complicated and difficult to understand. People would end up asking why case X doesn't work, if it has a subtle ambiguity.

For example:

• Neither type can be an interface or generic parameter
• If one type is an enum or a numeric type, the other must be a class other than object or Enum
• If one type is a delegate, the other must not also be a delegate type (nor object, Delegate, nor MulticastDelegate)
• One type cannot inherit the other
• All of these rules apply to any types implicitly convertible to the parameter types
• Both types must be sealed or must be value types

(some of these rules could be enforced at the callsite instead)

In practice, such a feature would have so many restrictions as to be almost worthless.

Therefore, this feature would start with -10,000 points.

It would also create a whole new category of breaking changes. Unsealing a type, adding implicit conversions, or other seemingly trivial things could now break client code.