Add rule to always inline let keyword when destructuring enum cases and tuples

[calda]

Summary

This PR proposes a new rule to always inline the let keyword when destructuring enum cases and tupes

When destructuring an enum case or a tuple, place the let keyword inline, adjacent to each individual property assignment

// WRONG
switch result {
case let .success(value):
  // ...
case let .error(errorCode, errorReason):
  // ...
}

// WRONG
guard let case .success(value) else { 
  return 
}

// RIGHT
switch result {
case .success(let value):
  // ...
case .error(let errorCode, let errorReason):
  // ...
}

// RIGHT
guard case .success(let value) else {
  return
}

Reasoning

1. Consistency: We should prefer to either always inline the let keyworkd or never inline the let keyword. In Airbnb's Swift codebase, we observed that inline let is used far more often in practice (especially when destructuring enum cases with a single associated value).

2. Clarity: Inlining the let keyword makes it more clear which identifiers are part of the conditional check and which identifiers are binding new variables, since the let keyword is always adjacent to the variable identifier.

// `let` is adjacent to the variable identifier, so it is immediately obvious 
// at a glance that these identifiers represent new variable bindings
case .enumCaseWithSingleAssociatedValue(let string):
case .enumCaseWithMultipleAssociatedValues(let string, let int):

// The `let` keyword is quite far from the variable identifiers, 
// so its less obvious that they represent new variable bindings
case let .enumCaseWithSingleAssociatedValue(string):
case let .enumCaseWithMultipleAssociatedValues(string, int):

Please react with 👍/👎 if you agree or disagree with this proposal.

[bachand]

I am having trouble following 3) in the reasoning. Can you make it more clear to me?

[calda]

I am having trouble following 3) in the reasoning. Can you make it more clear to me?

I removed this example because I don't think it added much value