feat: recognize the native worker runtime (gRPC durable protocol)

Add WorkerRuntimeType.Native (and Golang) and treat them like the other
gRPC-protocol runtimes (.NET isolated, Java) so Durable Functions works for
the Azure Functions Go worker.

The Go worker runs under the native worker model: its app sets
FUNCTIONS_WORKER_RUNTIME to "native" (see the worker's samples and
TECHNICAL_SPEC), and the worker provider declares "language": "golang". The
durable extension reads FUNCTIONS_WORKER_RUNTIME via GetWorkerRuntimeType,
so it sees "native". Some host builds surface "golang" instead (the worker's
integration tests launch func with FUNCTIONS_WORKER_RUNTIME=golang), so both
values are recognized; both identify the Go native worker, which uses the
gRPC out-of-process protocol exclusively (never the legacy HTTP shim).

- IPlatformInformation: new WorkerRuntimeType.Native and Golang. The host
  parses FUNCTIONS_WORKER_RUNTIME via Enum.TryParse(value.Replace("-",""),
  ignoreCase), so "native"/"golang" map to these values.
- DurableTaskExtension: select the gRPC (MiddlewarePassthrough) protocol for
  Native/Golang, alongside DotNetIsolated/Java/Custom. This routes
  orchestrator/activity execution through OutOfProcMiddleware's trigger
  dispatch and stands up the local gRPC server the worker's durable client
  connects to (delivered to the worker as the DurableClient binding's
  rpcBaseUrl). Also mark them as not needing the legacy local HTTP RPC
  endpoint.
- AzureStorageDurabilityProviderFactory: include Native/Golang in the set of
  runtimes that use a separate queue for entity work items, consistent with
  the other gRPC-protocol runtimes.

Execution remains trigger-replay: the host invokes the orchestration/
activity trigger over FunctionRpc with the encoded request and reads the
worker's encoded response, exactly as for .NET isolated and Java. The gRPC
server stays management-only (it does not serve a work-item stream).

Author: ahmedmuhsin

src/WebJobs.Extensions.DurableTask/AzureStorageDurabilityProviderFactory.cs

@@ -77,6 +77,8 @@ public AzureStorageDurabilityProviderFactory(
             WorkerRuntimeType runtimeType = platformInfo.GetWorkerRuntimeType();
             if (runtimeType == WorkerRuntimeType.DotNetIsolated ||
                 runtimeType == WorkerRuntimeType.Java ||
+                runtimeType == WorkerRuntimeType.Native ||
+                runtimeType == WorkerRuntimeType.Golang ||
                 runtimeType == WorkerRuntimeType.Custom)
             {
                 this.useSeparateQueueForEntityWorkItems = true;

src/WebJobs.Extensions.DurableTask/DurableTaskExtension.cs

@@ -171,6 +171,8 @@ public DurableTaskExtension(
             WorkerRuntimeType runtimeType = this.PlatformInformationService.GetWorkerRuntimeType();
             if (runtimeType == WorkerRuntimeType.DotNetIsolated ||
                 runtimeType == WorkerRuntimeType.Java ||
+                runtimeType == WorkerRuntimeType.Native ||
+                runtimeType == WorkerRuntimeType.Golang ||
                 runtimeType == WorkerRuntimeType.Custom)
             {
                 this.ConfigureForGrpcProtocol();
@@ -262,6 +264,10 @@ private TaskHubWorker InitializeTaskHubWorker()
                         WorkerRuntimeType.DotNetIsolated => false,
                         WorkerRuntimeType.Java => false,
 
+                        // the native worker (e.g. golang) uses the gRPC protocol, so it never starts the HTTP RPC server
+                        WorkerRuntimeType.Native => false,
+                        WorkerRuntimeType.Golang => false,
+
                         // everything else - assume the HTTP server
                         WorkerRuntimeType.Python => true, // This method will only be called for Python if we already know that we are using the HTTP protocol
                         WorkerRuntimeType.Node => true,

src/WebJobs.Extensions.DurableTask/IPlatformInformation.cs

@@ -61,6 +61,20 @@ public enum WorkerRuntimeType
         /// </summary>
         Custom,
 
+        /// <summary>
+        /// Native worker runtime, out-of-process via the gRPC protocol. This is the
+        /// FUNCTIONS_WORKER_RUNTIME value ("native") used by compiled-language workers
+        /// such as the Azure Functions Go worker.
+        /// </summary>
+        Native,
+
+        /// <summary>
+        /// Go (golang), out-of-process via the gRPC protocol. This matches the Go
+        /// worker provider's declared language; some host builds surface it as the
+        /// FUNCTIONS_WORKER_RUNTIME value instead of "native".
+        /// </summary>
+        Golang,
+
         /// <summary>
         /// Unknown worker runtime.
         /// </summary>