Added automatic fixes and suggestions to make this rule more easy to use.

I added following fixes and suggestions for particular types in boolean context (also added to docs):

• boolean - Always allowed - no fix needed.
• string - (when allowString is false) - Provides following suggestions:
  • Change condition to check string's length (str → str.length > 0)
  • Change condition to check for empty string (str → str !== "")
  • Explicitly cast value to a boolean (str → Boolean(str))
• number - (when allowNumber is false) - Provides following suggestions:
  • Change condition to check for 0 (num → num !== 0)
  • Change condition to check for NaN (num → !Number.isNaN(num))
  • Explicitly cast value to a boolean (num → Boolean(num))
• object | null | undefined - (when allowNullableObject is false) - Provides autofix:
  • Change condition to check for null/undefined (maybeObj → maybeObj != null)
• boolean | null | undefined - Provides autofix:
  • Explicitly treat nullish value the same as false (maybeBool → maybeBool ?? false)
• string | null | undefined - Provides following suggestions:
  • Change condition to check for null/undefined (maybeStr → maybeStr != null)
  • Explicitly treat nullish value the same as an empty string (maybeStr → maybeStr ?? "")
  • Explicitly cast value to a boolean (maybeStr → Boolean(maybeStr))
• number | null | undefined - Provides following suggestions:
  • Change condition to check for null/undefined (maybeNum → maybeNum != null)
  • Explicitly treat nullish value the same as 0 (maybeNum → maybeNum ?? 0)
  • Explicitly cast value to a boolean (maybeNum → Boolean(maybeNum))
• any and unknown - Provides following suggestions:
  • Explicitly cast value to a boolean (value → Boolean(value))

Edit: updated order and messages to match the actual ones

I used the word "explicitly" where it doesn't change the runtime behavior, even when types are wrong.

The autofix for nullable object theoretically changes the behavior (e.g. if you somehow get empty string or 0 instead of null or object), but it's not enabled by default and there's only one obvious way of handling it if enabled. In practice it shouldn't make a difference when you compare object to null vs implicitly cast to boolean.

The second autofix for nullable boolean doesn't change the behavior and it's usually what the programmer wants. That's why I decided to make it automatic instead of suggestion.

I left some TODO comments about suggestions which are wrong for bigint (it's treated the same as number in the rule). They shouldn't cause a huge breakage when applied (in worst case TypeScript should report error after applying the suggestions). I think they can be fixed separately in a followup PR.