[runtime] Extend JNI remapping support - #12847

## Summary

Remove the experimental build-time managed-assembly rewriting approach for R8 so any future assembly-rewriting design can start from a clean foundation.

This cleanup is related to #12535 and the original prototype in #12575.

## What this PR undoes

This removes the managed rewriting implementation developed across the R8 obfuscation stack:

- #12629 added the PE metadata rebuild substrate.
- #12630 added managed JNI metadata rewriting from R8 mappings.
- #12631 added rewriting for generated trimmable type-map assemblies.
- #12632 and #12634 integrated and tested that rewriting approach for CoreCLR and NativeAOT.

Concretely, this PR removes the rewrite task, rewrite-only metadata/IL utilities, dedicated tests and fixtures, and the XA4325/XA4326 resources and documentation. The intent is to abandon this implementation rather than preserve an unused rewriting stack that a future design would need to work around.

## What remains in place

- The generic `R8Mapping` parser introduced in #12628 remains, along with its tests and the `MSBuildDeviceIntegration` consumer. It is independently useful for reading R8 mapping files.
- The ordinary R8 configuration and `private-members` obfuscation/optimization policy from #12668 remain unchanged. This PR does **not** disable R8 or remove private-member obfuscation.
- Existing D8/R8 packaging, ProGuard rule handling, and non-rewriting build behavior remain unchanged.
- Runtime remapping remains active as the stacked follow-up work in #12847, #12848, #12692, and #12844. Those PRs implement the alternative opt-in strategy without managed assembly rewriting and are not part of this cleanup diff.

We may revisit managed assembly rewriting in .NET 12 based on customer feedback and performance data, but with a fresh design rather than this implementation.

## Validation

- Built `Xamarin.Android.Build.Tasks`
- Ran `Microsoft.Android.Build.Tasks.Tests`
- Ran `Microsoft.Android.Sdk.TrimmableTypeMap.IntegrationTests`
- Built `MSBuildDeviceIntegration`
- Ran focused `R8MappingTests`

Depends on #12847.

This layer adds the producer-side implementation for R8 JNI runtime remapping. It parses R8 mappings, scans linked managed metadata read-only to retain surviving entries, supports NativeAOT post-ILC retention, and generates forward/reverse type, method, field, descriptor, indexed, count, and empty LLVM lookup tables.

Managed assemblies are never rewritten or reconstructed by this change.

This intentionally contains no public product mode, policy, pipeline target wiring, NativeAOT deferred-link orchestration, documentation, or end-to-end device tests; that wiring remains for the later #12692 layer.

Context: #12535

This is the product policy and build-orchestration layer for opt-in R8 runtime JNI remapping. It is stacked on:

- #12846 — removes the abandoned managed-assembly rewriting implementation
- #12847 — adds generic runtime JNI remapping support
- #12848 — parses the final R8 mapping and generates native runtime lookup tables

A final dependent PR, #12844, moves the .NET-only R8 mapping task into `Microsoft.Android.Build.Tasks`.

This PR does not rewrite managed assemblies. Managed bindings retain their original JNI names; the lower layers generate native tables that translate lookups to the names and descriptors emitted by R8.

## Opt-in

For a trimmed CoreCLR or NativeAOT application:

```xml
<PropertyGroup Condition="'$(Configuration)' == 'Release'">
  <AndroidLinkTool>r8</AndroidLinkTool>
  <AndroidTypeMapImplementation>trimmable</AndroidTypeMapImplementation>
  <PublishTrimmed>true</PublishTrimmed>
  <AndroidR8ObfuscationMode>runtime-remapping</AndroidR8ObfuscationMode>
</PropertyGroup>
```

`runtime-remapping` is the sole opt-in; there is no separate enable property. It does not apply to library projects. The existing `private-members` and `disabled` behavior remains unchanged. Unknown mode values report XA1050, while incompatible runtime-remapping configurations report XA4329.

## Build orchestration

- Runs R8 once, after ILLink or all per-RID NativeAOT ILC compilations.
- Converts that final mapping into runtime remapping tables before native linking.
- Defers NativeAOT linking until the shared R8 pass completes, then relinks each RID without rerunning ILC.
- Applies the runtime-remapping-specific bootstrap, native-callback, manifest, resource, and JNI safety keep rules.
- Preserves existing MAM remapping precedence and asset handling.
- Tracks mapping inputs, generated XML, native table sources, task assemblies, native-link inputs, configuration changes, missing-output recovery, and opt-out for incremental builds.
- Preserves generated ProGuard rule timestamps when their contents are unchanged so managed-only rebuilds do not rerun R8 unnecessarily.

## Coverage in this layer

Host tests cover mode defaults, configuration validation, keep-rule policy, NativeAOT ProGuard configuration, packaging metadata, and incremental behavior. Build/device integration tests cover renamed types and members, constructors, overloads, inherited lookups, peer activation, single-pass ordering, multi-RID builds, missing-output recovery, and opt-out for CoreCLR and NativeAOT.

The generic lookup semantics and mapping/table-generation tests live in #12847 and #12848 respectively.

## Experimental limitations

NativeAOT literal matching is conservative and can retain extra entries. Arbitrarily computed JNI names may require explicit remaps or keep rules. Conservative public/nested-class, interface, bootstrap, and native-callback keeps limit obfuscation. Existing Intune/R8 conflict handling is not full remapping-chain composition, and ambiguous reverse mappings for merged classes are omitted. This remains an experimental opt-in, not a production-readiness claim.

----

- [x] Useful description of why the change is necessary.
- [x] Links to related issues and dependent layers.
- [x] Unit and integration coverage.

Fixes: #12535

…mbly (#12844)

## Summary

This PR is stacked on and depends on #12692. That parent is built on the focused lower chain #12846, #12847, and #12848.

This final layer is only a task-assembly boundary change for the runtime-R8 remapping producer. It moves `GenerateR8JniRemapping` and the .NET-only helpers it directly requires into `Microsoft.Android.Build.Tasks`:

- `JniRemappingAssemblyScanner`
- `R8Mapping`
- `JniDescriptorText`
- `NativeAotJniRetention`

The generic runtime table producer remains in `Xamarin.Android.Build.Tasks`: `GenerateJniRemappingNativeCode` and `JniRemappingNativeCodeGenerator` are unchanged and continue to serve both MAM and R8 remapping.

The relocation also:

- loads only `GenerateR8JniRemapping` from the modern assembly using the existing Full/Core `UsingTask` pattern
- tracks both modern and legacy task assemblies in mixed incremental targets
- links only the metadata helpers required by the read-only scanner
- packages `ELFSharp.dll` beside the modern task assembly under `tools/net`
- keeps net10 `MSBuildDeviceIntegration` compatible by linking `R8Mapping.cs` instead of referencing the net11 task project
- preserves a test-only aliased legacy task reference to validate generated XML through `MergeRemapXml` and `GenerateJniRemappingNativeCode`

This PR does not restore or relocate the removed managed assembly rewriter, rewrite planners/rebuilders, rewrite-only tests, or `XA4325`/`XA4326` behavior.

## Validation

- `Microsoft.Android.Build.Tasks` build
- `Xamarin.Android.Build.Tasks` build
- 86 focused modern R8 remapping tests
- 41 trimmable typemap integration tests
- `MSBuildDeviceIntegration` project build
- verified packaged `tools/net/ELFSharp.dll`
- final read-only review found no blocking issues