A copy constructor shouldn't prevent an automatic addition of a default instance constructor for a record. (#47850)

https://github.com/dotnet/csharplang/pull/3913

* Allow record's `parameter_list` to be empty.

Related to #47091
https://github.com/dotnet/csharplang/blob/master/meetings/2020/LDM-2020-08-24.md#base-calls-on-parameterless-records
https://github.com/dotnet/csharplang/pull/3900

Restrict readonly from being applied directly to init accessors, and prevent them from being considered readonly by the language.

* Remove langversion restriction for source generators.

Fixes #47614
See also https://github.com/dotnet/csharplang/commit/2661a4b3950d2ec5c557b025af13e52ba200fd05

Bye for now!

* Use a distinct diagnostic ID when an exhaustiveness report uses an unnamed enum value.
Fixes #47066

Related to #47357.

This is a mitigation for the threading issue discussed in https://github.com/dotnet/roslyn/issues/35818. When building VS, there is a flaky threading issue where an interpolation with multiple parts can end up with different nodes on different threads, causing an optimization in `SetParentOperation(ImmutableArray)` to be invalid. This makes the optimization much narrower, ensuring that it is actually valid for this case.

The specific scenario here is an interplotated string with multiple parts. The steps are:
1. 2 threads attempt to get the children of an interpolated string operation at the same time.
2. Thread 1 gets the child for the first part of the string and caches it.
3. Thread 2 gets the child for the first part of the string and gets that same cached element.
4. Both threads attempt to get child 2. Neither hits the cache, so they get different nodes.
5. Both threads construct the array of interpolated string parts.
6. Thread 1 sets the parent of the interpolated string parts to be itself.
7. Thread 2 attempts to set the parent of the interpolated string parts to be itself. This returns early, because part 1 already has a parent, leaving part 2 with an unset parent.
8. Later, thread 2 asks for the parent of part 2. It is unset, violating the invariants, and we infinite loop.

As an additional mitigation step, we also ensure that the process of constructing an interpolated string's inserts does not hit the cache.  Since we never ask for an operation within a single expression, this will prevent 2 threads from seeing the same first element and differing subsequent elements.

* Decision dag: union the set of values when there are two predecessor states.

If a state has no set of values for a temp on one of the edges, that means it is unrestricted.
This fixes a bug in decision dag construction.  I was not able to construct a test that is
affected, but the change makes a visible difference in an internal dump of the decision dag
for the newly added test `MultiplePathsToState_01`, which we walked through in a compiler
team meeting on 2020-09-09.

* Use a builder as suggested in review.

This allows `init` properties on readonly structs, readonly properties in structs, and allows `init` accessors to be declared readonly themselves. Fixes https://github.com/dotnet/roslyn/issues/47612.

Fixes #47471