Widen ActorTaskScheduler(ActorCell) ctor to protected internal (#8158)

The two virtual hooks OnBeforeTaskStarted / OnAfterTaskCompleted have
always been protected, clearly intended as extension points for
libraries that need to observe async message handler lifetimes. But the
ctor was internal, blocking any external subclass from actually hooking
them without reflection or runtime codegen.

Widening the ctor to protected internal finishes the extension point
that was already half-exposed. protected lets external libraries
subclass; the internal part preserves the existing new
ActorTaskScheduler(this) call site in ActorCell without requiring a
derived type there.

Motivation: Phobos (the Akka.NET observability plugin) needs to
subclass ActorTaskScheduler to keep akka.msg.recv spans open for the
full duration of ReceiveAsync / CommandAsync handlers. Today the span
closes at the first await yield point, hiding all post-await work from
traces. Customers running Phobos on both .NET and .NET Framework hit
this, and we need a cross-runtime fix — IgnoresAccessChecksTo works
only on CoreCLR, reflection can't synthesize a subclass with an
inaccessible base ctor, and runtime codegen is AOT-hostile. Widening
the ctor is the clean fix.

No behavior change. Pure access widening, no caller breaks.

Author: Aaronontheweb

src/core/Akka.API.Tests/verify/CoreAPISpec.ApproveCore.DotNet.verified.txt

@@ -2724,6 +2724,7 @@ namespace Akka.Dispatch
     }
     public class ActorTaskScheduler : System.Threading.Tasks.TaskScheduler
     {
+        protected ActorTaskScheduler(Akka.Actor.ActorCell actorCell) { }
         public object CurrentMessage { get; }
         public override int MaximumConcurrencyLevel { get; }
         protected override System.Collections.Generic.IEnumerable<System.Threading.Tasks.Task> GetScheduledTasks() { }

src/core/Akka.API.Tests/verify/CoreAPISpec.ApproveCore.Net.verified.txt

@@ -2742,6 +2742,7 @@ namespace Akka.Dispatch
     }
     public class ActorTaskScheduler : System.Threading.Tasks.TaskScheduler
     {
+        protected ActorTaskScheduler(Akka.Actor.ActorCell actorCell) { }
         public object CurrentMessage { get; }
         public override int MaximumConcurrencyLevel { get; }
         protected override System.Collections.Generic.IEnumerable<System.Threading.Tasks.Task> GetScheduledTasks() { }

src/core/Akka/Dispatch/ActorTaskScheduler.cs

@@ -37,10 +37,23 @@ protected virtual void OnBeforeTaskStarted() { }
         protected virtual void OnAfterTaskCompleted() { }
 
         /// <summary>
-        /// TBD
+        /// Creates a new <see cref="ActorTaskScheduler"/> bound to the given
+        /// <see cref="ActorCell"/>.
+        ///
+        /// Exposed as <c>protected internal</c> so external libraries (notably
+        /// Phobos, the Akka.NET observability plugin) can subclass
+        /// <see cref="ActorTaskScheduler"/> and override
+        /// <see cref="OnBeforeTaskStarted"/> / <see cref="OnAfterTaskCompleted"/>
+        /// to observe async message handler lifetimes without reflection or
+        /// runtime codegen. The two virtual hooks have always been
+        /// <c>protected</c>, so widening the constructor to match finishes an
+        /// extension point that was already half-exposed. The <c>internal</c>
+        /// portion preserves the existing <c>new ActorTaskScheduler(this)</c>
+        /// call site inside <see cref="ActorCell"/> without requiring a
+        /// derived type.
         /// </summary>
-        /// <param name="actorCell">TBD</param>
-        internal ActorTaskScheduler(ActorCell actorCell)
+        /// <param name="actorCell">The cell this scheduler is bound to.</param>
+        protected internal ActorTaskScheduler(ActorCell actorCell)
         {
             _actorCell = actorCell;
         }