Detect references to method/property in bound method group/property group using semantic model APIs. Also provide a different message for methods which have name only references.

Do not crash ExtractMethod when we run into a dataflowanalysis result we didn't account for. (#30554)

* Do not crash when we run into a dataflowanalysis result we didn't account for.

* Add comment.

* remove

* Improve error strings.

* Simplify.

* Assume the variable is read.

* Add test.

* KeyValueMessage.

1. Bail out for explicit interface implementations for properties, we only did so for methods.
2. Bail out for types with StructLayoutAttribute
3. Conservatively handle member references inside DebuggerDisplayAttribute argument by doing a simple string contains check.

It was initially implemented as a potential code style analyzer, but we have agreed on it being a code quality analyzer, with no special IDE options/preferences logic.
I have switched the analyzer to be implemented just like a regular third party analyzer.
This cleans up the implementation quite a bit, and also fixes the issue where we reported hidden diagnostics for this analyzer instead of suggestion diagnostics as the default code style diagnostic severity is hidden.
I have also reverted AbstractCodeStyleDiagnosticAnalyzer.cs to the state before this analyzer was implemented.

1. Break the analyzer into two separate diagnostics for flagging unused and unread members. Latter rule has no code fix.
2. Remove all UI option elements for the added diagnostics and turn the rules off by default for now.
3. Bail out for invalid operations and syntax errors.
4. Handle doc comments and nameof - report unread member diagostics instead of unused member diagnostics if referenced in non-read/write context.

Analyzer flags two cases: members with no read/writes and members with only writes.

1. Members with no read or writes: `Type '{0}' has an unused private member '{1}' which can be removed.`
2. Only writes: `Type '{0}' has a private member '{1}' which can be removed as the value assigned to it is never used.`

Code fix removes the unused member declaration.
Fixes #24225

Open questions:
1. Current analyzer design uses a single code style option for all members and both the above kinds of unused members. We can potentially have multiple options, but this should probably be done based on feedback.
2. Should the analyzer use different diagnostic IDs for the above two kinds of unused members? This will mean that the FixAll experience will need multiple iterations for removing unused members.
3. Should we update the code fix (or have an additional code fix) that also updates the write references for the case (2) above? Or is it better to leave the references to break the code so the user can analyze if the value being assigned can also be removed. The PR current chooses the latter approach as it is more conservative and unlikely to cause silent breaks.

Add refactoring to convert foreach loop into linq invocations (Select, SelectMany and Where invocations)

Adds one of the refactorings mentioned in #8953

```
//
// INPUT:
//   foreach (var n1 in c1)
//      foreach (var n2 in c2)
//          if (n1 > n2)
//              yield return n1 + n2;
//
// OUTPUT:
//   c1.SelectMany(n1 => c2.Where(n2 => n1 > n2).Select(n2 => n1 + n2))
//
```

These are missing languages which production team delivered today.