[MWF] Fix bug in DataGridViewRowCollection Clear() introduced by recent commit

7d1b878fbf13462a282860c6d1dd493a48d7b1eb altered the behavior of removing rows, breaking
the DataGridViewRowCollectionTest.ClearRows () test

Before the change, this is what happened when the list was cleared
(the number in brackets is the value of the Index property of the DataGridViewRow):

[0]  Remove   [1]  ReIndex  [0] Remove  [1] ReIndex  [0]
[1] --------> [2] --------> [1] ------> [2] -------> [1]  ...
[2]           [3]           [2]
[3]

After the offending commit, ReIndex is only called after the list is cleared, which means
the Index property of the rows is never updated (as there are no items in the list).

The fix is to explicitly set the Index of each row to 0.
This was the end result before the commit anyway, so we can omit the ReIndex call entirely.

[system.net.http] Update range checks for invalid characters. Fixes #18800

Fix "make dist" error caused by renamed sgen-marksweep-drain-gray-stack.h

Fix build (SHARED_EXT was renamed to MONO_SOLIB_EXT in 4342bce4412bdd5fc70efcf9d055e23a7a908b64)

[system.net.http] Escape more RFC5987 characters. Fixes #24785

Merge pull request #1430 from akoeplinger/readme

Improve README.md and focus on relevant content

Merge pull request #1319 from directhex/systemwide-per-arch-aot-cache

Add a third AOT location, alongside ~/.mono/aot-cache and the assembly dir

Improve README.md and focus on relevant content

Before, the first thing the user saw were instructions for niche platforms like Itanium or Solaris.
Instead, we now just link to the "Compiling Mono" guides for OSX, Linux and Windows on the Mono website.

Additionally, a bunch of instructions were outdated / no longer relevant, updated those.

The "Configuration options" section was moved to the bottom of the readme, it was pretty long and pushed
the other sections into oblivion.

Merge pull request #1407 from chrisvire/bug-24587

[MWF] Fix focus issue when removing last item in ListView

Merge pull request #1424 from akoeplinger/remove-enable-nunit-tests

Remove --enable-nunit-tests option from build system

[mcs] Remove declaration expression named argument parsing (not part of the language yet). Fixes #24784

[sgen] Fix concurrent M&S.

Bump referencesource to fix mobile profile compilation of System.ComponentModel.DataAnnotations

Fix mobile build wrt System.Core changes

[System] Make it build with the MonoTouch profile

Drop dead notes/code

Fixes build

[sgen] Use all 3 lower vtable bits on 32 bits.

We can't actually use the trick of setting both the pinned and forwarded
bits to indicate cemented objects because the Tarjan bridge requires those
two bits never be set at the same time.

[sgen] Align vtable pointers to 8 bytes on 32 bits, too.

[sgen] Mempool allocations should be 8 byte aligned.  Fix this on 32 bits.

The `MonoMemPool` struct is not a multiple of 8 bytes large, so we need
to align up to get the actual start of the pool data.

[sgen] Remove unused defines.

[sgen] Document descriptor types in comment.

[sgen] Symbolic constants for pointer-free descriptor types.

[sgen] Separate descriptor type enums.

[sgen] Use a symbolic constant for the descriptor type mask.

[sgen] Rename `LARGE_BITMAP` to `BITMAP`.

There's only one bitmap descriptor type left and no need to
distinguish between large and small.

[sgen] Use `guint64` for most counters, not `long long`.

[sgen] Fix cementing tag bit on 32 bits.

We used the third-lowest vtable bit to tag cemented objects.  On 32 bits,
vtables are only 4-byte aligned so we have to make do with 2 bits.

[sgen] Remove DESCRIPTOR_FAST_PATH option - don't use it.

We're removing options that we've introduced for experimentation but that
didn't pan out.

[sgen] Remove MARK_ON_ENQUEUE option - always use it now.

We're removing options that we've introduced for experimentation but that
didn't pan out.

[sgen] Remove GRAY_QUEUE_HAVE_DESCRIPTORS option - always use it now.

We're removing options that we've introduced for experimentation but that
didn't pan out.

[sgen] Remove USE_PREFETCH_QUEUE option - don't use it.

We're removing options that we've introduced for experimentation but that
didn't pan out.

[sgen] Remove BLOCK_INFO_IN_HEADER option - always use it now.

We're removing options that we've introduced for experimentation but that
didn't pan out.

[sgen] Use a smaller slot size scaling factor.

The factor we used previously gave us object sizes in increments that made
some benchmarks use quite a lot more memory than necessary.  In particular,
we didn't have a size for 24 byte objects (on 64 bits), just for 16 and 32.

[sgen] Make block size fastenable.

[sgen] Fix card scanning with larger block sizes.

The card scanning code assumed that the size of the block header is less
than the size of a card.  If we put the block info into the header and increase
the block size enough, that assumption isn't true anymore, because the
mark bits take up space in proportion to the block size.

[sgen] Experimental pre-fetch scan fast-path.

The idea here is to first extract all the references within an object
and then to process them, pre-fetching the objects they point to a few
steps ahead.

[sgen] Fix build for mark-on-dequeue.

[sgen] Nicer visualization of concurrent collector pauses in gcpausevis.py.

[sgen] Separate binary protocol entries for concurrent update and finish.

[sgen] Flush binary protocol buffers after unloading a domain.

When the runtime shuts down the last thing the GC usually hears about it
is that the root domain is unloaded.  If we don't flush the binary protocol
buffers at that point, we lose entries.

[sgen] Fix build on C99.

[sgen] Fix build with heavy statistics.

[sgen] Rename sgen-major-scan-object.h to sgen-marksweep-scan-object-concurrent.h.

[sgen] Remove some dead code in sgen-major-scan-object.h.

[sgen] Unify scanning code a bit.

We still have two separate implementations of the scanning code: The optimized
one and the old one.  The old one is still needed because it supports the concurrent
collector.  For the non-concurrent collector we can now use the optimized
implementation, however.

[sgen] Add/fix some assertions.

[sgen] Add some missing binary protocol invocations.

[sgen] New protocol entry for processing of individual reference.

[sgen] In binary protocol grep, gray en-/dequeue must not always match.

[sgen] Remove binary protocol entry for null dequeue.

[sgen] Fix build on highest debug level.

[sgen] Handle copy object failure.

This is just a verbatim copy of the old code.  It's unlikely it's ever
been tested, though.

[sgen] Increase debug level of assertions in inner loops.

[sgen] Remove dead code.

This was still left from the parallel collector.

[sgen] Fix build with prefetch queue enabled.

[sgen] Make new M&S parameters fastenable.

Fasten is a small tool for optimizing compile-time options:

    https://github.com/evincarofautumn/fasten

It does that by parsing source files for numbers that have been marked
as "fastenable", and fiddling around with them.  We do this for all
the new optimizations.

[sgen] Support evacuation in the optimized mark/scan loop.

We actually implement two separate mark/scan loops: One that doesn't
support evacuation and one that does.  We dynamically choose which one
to use.  The evacuation-less loop is faster, so we use it whenever we can.

[sgen] Move drain_gray_stack() to copy/mark header file, too.

This inlines the scan/copy functions, so if we duplicate them we need
to duplicate this, too.

[sgen] Remove old copy/mark function.

The new, optimized function can now do everything the old one did, so
let's get rid of it.

[sgen] Move copy/mark function into separate header file.

So we can later include them twice, once with support for evacuation
and once without.

[sgen] Support evacuation again.

The performance impact of this is significant, so we will later make
two separate scan functions: one with evacuation and one without.

[sgen] Support split nursery again.

This might degrade performance, in which case we'll special-case it
later on.

[sgen] Unify the two small object mark cases again.

The only difference between these two cases was that we used to
different heavy statistics counters.  We can do that within a single
case.

[sgen] Use MS_MARK_OBJECT_AND_ENQUEUE where we expanded it previously.

It's still the same code, so use the macro directly.

[sgen] Always inline the optimized copy function.

This is a huge win for some benchmarks.

[sgen] Never fall back to the old copy function.

[sgen] Use scanning macro in optimized loop.

We expanded this macro previously, but it's still the same code, so
use the macro directly.

[sgen] New SMALL_PTRFREE descriptor type for faster has_references checking.

We use 3 to denote SMALL_PTRFREE, and 7 for COMPLEX_PTRFREE, so we can
check for both simply with ((desc & 3) == 3).

[sgen] Only enqueue objects with references.

[sgen] Look at descriptor, not block, to see whether object has references.

[sgen] Special descriptor encoding for strings.

The complex pointer-free type carries no additional information.  We use its
data to mark strings so we can determine object size quicker.

[sgen] Faster generic large bitmap scanning if CTZ builtin is available.

[sgen] Remove small bitmap descriptor type.

The reason for having a small bitmap was that we could encode the object
size in the descriptor.  The main attraction for having object size handy is that
we can quickly check whether an object is in the small object major heap or
in the LOS.  We solve this problem by always using complex descriptor types
for large objects, so now we can tell whether an object is small just by looking
at the descriptor type.

[sgen] Heavy statistics on copied object descriptors.

[sgen] Heavy statistic counter for scanning of no-ref objects.

[sgen] Use HANDLE_PTR in the fast-path, too.

We had just expanded the macro verbatim and never changed it, so
there's no point in not using it directly.

[sgen] Optional scanning without the small bitmap fast path.

To experiment with different optimization combinations.

[sgen] Fix heavy statistics in mark-scan loop.

[sgen] Limit run-length descriptors to small object size, too.

To identify more small objects quicker.

Since we now use the runl-length descriptor types to indicate object
size as well, and strings can have any size, we can't use that type
for strings anymore, so we use the complex type which forces us to
look up its size to determine whether it's a small or large object.

[sgen] Make mark on enqueue vs dequeue configurable.

So we can experiment with a variety of optimization configurations.

[sgen] Make block info in header optional.

So we can experiment with a variety of optimization configurations.

[sgen] Tag cemented objects so we don't have to go through the hash.

We can do the cemented check faster by using the third vtable bit to
tag cemented objects (in addition to the pinned bit).  In workloads
that are heavy on cementing (like `lcscbench` or `perimeter`) this
significantly increases performance.

[sgen] Prefetch mark bits, not block start.

When prefetching, we calculate which mark bits we need and prefetch
those for writing.  The object itself we prefetch for reading.

[sgen] Put block info into blocks.

Another experiment: What if we put the whole block info into the block
itself, not just a pointer to it.  There's one less indirection we
need to do.  On the other hand, many of them will share the same cache
lines.  So do the pointers to the block infos, though.

[sgen] Bring mark-scan loop stats up to date.

[sgen] Also prefetch the (potential) block header.

When we scan a small object in the major heap we have to read the
block header of its block.  It makes sense to prefetch that as well,
in addition to the object itself.

[sgen] Count scanned objects.

[sgen] Mark on dequeue, not enqueue.

This is another experiment.

When marking on enqueue, what we need to do is look at the object
we're about to enqueue, to check whether it's a small or large object.
Then, when we dequeue to scan, we look at the object again, so we
essentially fetch each live object header twice.

With mark on dequeue, when we encounter a pointer we always enqueue
it, without even looking at the object.  Only when we dequeue do we
figure out whether it's marked yet, and thus whether we need to scan
it.

[sgen] Make enqueuing descriptors compile-time optional.

We want to test this in combination with other changes, so we make
each of them configurable.

[sgen] Make prefetch queue compile-time optional.

We want to benchmark the prefetch queue in combination with other
changes, so we make each of them configurable.

[sgen] Prefetch queue for optimized mark/scan loop.

We put a short FIFO between the gray stack and the actual scanning, to
be able to prefetch objects ahead of time, with an adjustable delay.

[sgen] Optimized mark/scan loop for major collections.

The basic idea here is to make a loop that combines dequeuing from the
gray queue, scanning and marking/copying/enqueuing, with redundancies
removed and special-casing of the common case.

We make the small bitmap type descriptor only apply to small (as
opposed to LOS) objects so that we can quickly check in that case
whether an object is in the LOS or not without actually looking up its
size.

We disable evacuation and the split nursery because the code doesn't
support them yet.

[gc] Remove the `new object count` counter, because it's useless.

Without heavy statistics it counts almost no objects, and even with
heavy statistics turned on, it doesn't count everything.  SGen has an
accurate counter when heavy statistics are turned on.

[sgen] Fix build with binary protocol.

Merge pull request #1426 from ignacionr/webclient-delay-file-creation

Webclient delay file creation

[corlib] Implement ExecutionContext flow for async infrastructure. Fixes #24757

Merge pull request #1398 from jwestfall69/dgv-first_row_index

[MWF] DataGridView: ensure first_row_index will be valid after row removal

Merge pull request #1396 from jwestfall69/dgvrc-clear-speedup

[MWF] DataGridViewRowCollection Clear() speed up

Bump the version.