---

This section details on the original issue you should resolve

<issue_title>Offer to add usings for fully qualified names</issue_title>
<issue_description>It would be nice to have a codefix that offered to add usings for a fully qualified type and then simplified the name.

so if I had this:

public static async System.Threading.Tasks.Task<string> GetGoodDealsAsync()
{
	using HttpClient client = new HttpClient();
    using HttpResponseMessage response = await client.GetAsync("http://good-deals.com/");
    using HttpContent content = response.Content;
	string result = await content.ReadAsStringAsync();
	return $"Here are the good deals: {result}";
}

it would offer to do this:

using System.Threading.Tasks;

public static async Task<string> GetGoodDealsAsync()
{
	using HttpClient client = new HttpClient();
    using HttpResponseMessage response = await client.GetAsync("http://good-deals.com/");
    using HttpContent content = response.Content;
	string result = await content.ReadAsStringAsync();
	return $"Here are the good deals: {result}";
}
``` </issue_description>

<agent_instructions>Copilot, you're going to be creating a whole new feature here.  

1. this will be a refactoring.   So you will be creating a CodeRefactoringProvider. 
2. This will work for C# and VB.  But we're just going to start by making C# work. 
3. You'll need to create an `AbstractAddImportCodeRefactoringProvider` in `Microsoft.CodeAnalysis.Features`.  This can sit next to AbstractAddImportCodeFixProvider.cs
4. The refactoring will work in the following fashion.  The refactoring will start with the location the user is at, and will see if it is on some name that binds to a namespace, and has a type name accessed off of it.  Note that this may be as simple as `System.Console` or as complex as `global::System.Console` or `System.Collections.Generic.List<int>` etc.  Because this is in the shared 'Features' layer, you should use `ISyntaxFactsService` to do the analysis here so that it will work for VB/C#.
5. If you find such a namespace name, then you will offer the user a code action to `Add import and simplify type name`.
6. When this code action runs, it will do 3 things:

1. It will add the `using` to the proper scope (namespace or compilation unit).  You can use `IAddImportsService` to help with this.
2. It will then both add the `Simplifier.Annotation` annotation to the namespace (or possibly namespace+type) name that it was invoked off of.  This way the code action infrastructure will attempt to remove that superfluous name after the `using` is added.
3. It will go through the file looking for types or expressions that start with some name, and will check if that name is a type-name in the new namespace it's about to add a `using` for.  These type names may now bind differently, or become ambiguous.  So the refactoring should attempt to bind the current name, and replace it with `SyntaxGenerator.TypeExpression(typeSymbol, true/false)` so that the name is now qualified appropriately.  If the name is ambiguous, this will stay.  But if it is not ambiguous, the code action infrastructure will remove that qualification that you added.  

1. You will then need to make a C# specific subclass of your abstract code refactoring provider.  There should be almost nothing in this.  It will exist just to properly export the `[ExportCodeRefactoringProvider(...)]` with a proper name and language binding.

Finally, add a lot of tests for this.  Add a new `AddUsingCodeRefactoringTests.cs` that sits next to `AddUsingTests.cs`.  This should use the VerifyCS pattern like `using VerifyCS = CSharpCodeRefactoringVerifier<...>;` pattern.

Test all your logic extensively.  Importantly, test simplification in all the interesting places a qualified type name could show up in a type-only location (like an inheritance list, parameter type, return type, typeof, `new T`, etc.).   And all the places where it could start an expression, and validate those.

Then, we want to test extensively that the logic to qualify existing names, and have them either become unqualified (if there is no ambiguity) or stay qualified (if there is) works.</agent_instructions>

## Comments on the Issue (you are @copilot in this section)

<comments>
</comments>