Deconstruct with same number of parameters but different signature -> compiler eror - c#-7.0

Question

I believe that this question is different from the linked duplicate because the linked question and answer don't directly address the same issue (I have added an update below that hopefully illustrates this).
Why is an error returned when there are two Deconstruct methods on a class with the same number of arguments but different types - see code below. Multiple Deconstruct methods with different numbers of arguments are fine. Compiler only complains when the 'Deconstruct' methods have the same number of arguments even though the arguments are different types
I would have thought Deconstruct would work the same way as other methods where methods can be overloaded by signature (same number of arguments, different types). Not sure it actually makes sense for a class to have two Deconstruct methods with different signatures or different number of arguments (see comments), but I was wondering if this error is due to a technical limitation or a design feature to prevent people doing this.
var person = new Person { ID = 123, FirstName = "Bob", MiddleName = "Tim", LastName = "Smith" };
//error CS0121: The call is ambiguous between the following methods or properties: 'Person.Deconstruct(out string, out string, out string)' and 'Person.Deconstruct(out int, out string, out string)'
// Deconstruct instance or extension method was found for type 'Person', with 3 out parameters and a void return type.
(string a, string b, string c) = person; //<=Errors on person here
...
public class Person
{
public bool ID { get; set; }
public int FirstName { get; set; }
public int MiddleName { get; set; }
public int LastName { get; set; }
public void Deconstruct(out int fname, out int mname, out int lname)
{
fname = FirstName;
mname = MiddleName;
lname = LastName;
}
public void Deconstruct(out bool id, out int fname, out int lname)
{
id = ID;
fname = FirstName;
lname = LastName;
}
}
Update
The answer can be found here
Specifically:
if there are overloads how this works then? var (x, y) = foo;
That is, there is no way to tell which overload to call when using var. That got me thinking about what would happen when overloading out methods and assigning to var. E.g. adding the following methods to Person
public void Foo(out int i)
{
i = 1;
}
public void Foo(out bool i)
{
i = false;
}
Then gives the following behaviour:
person.Foo(out int k); //calls Foo(out int i)
person.Foo(out bool m); //calls Foo(out bool i)
//Error CS0121 The call is ambiguous between the following methods or properties: 'Person.Foo(out int)' and 'Person.Foo(out bool)
person.Foo(out var i );
Which seems inconsistent with Deconstruct. Why does method overloading work so long as there is no var, but Deconstruct doesn't allow it even when assigning to different types?