fix(pool): harden pooled view-in-field — this-instance views, semantic IMemoryOwner, this-qualified owner (CodeRabbit + Codex)

Three precision/robustness fixes to the pooled view-in-a-field pass, each flagged
by review (the first two by BOTH CodeRabbit and Codex):

1. FP: the view-field alias map keyed the LHS with FieldName, so `other._view =
   _owner.Memory` recorded THIS instance's `_view` as aliasing `_owner` — a later
   handler read of this object's `_view.Span` would then falsely fire. Use
   ThisFieldName for the LHS, matching the release/read paths (this/bare only).

2. Recall: an owner field written `System.Buffers.IMemoryOwner<byte>` (or an alias,
   or a concrete type implementing IMemoryOwner) was missed by the
   `StartsWith("IMemoryOwner")` string check, so releasedAt stayed empty and the
   case was skipped. New `IsMemoryOwnerType` resolves the field's type SYMBOL
   (interface or via AllInterfaces); the cheap StartsWith still short-circuits the
   common unqualified spelling. IDisposable stays syntactic (unresolved customs).

3. Recall: `this._owner.Memory` was not recognised as a view (ViewOwner needs an
   IdentifierNameSyntax receiver). New `FieldViewOwner` accepts a this/bare-field
   receiver (ThisFieldName) for the `IMemoryOwner<T>.Memory` borrow, so both
   `_owner.Memory` and `this._owner.Memory` alias, while `other._owner.Memory`
   (another instance) does not.

Behaviour on the corpus is unchanged (the `_owner.Memory` view still aliases and
fires OWN002, the guarded after stays silent); the FP fix only narrows the map.
C# validated by CI.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Rg8kSk1YT14x7A1vo5zgED

Author: claude

frontend/roslyn/OwnSharp.Extractor/Program.cs

@@ -1109,6 +1109,25 @@ e is InvocationExpressionSyntax i
     return null;
 }
 
+// Is `t` System.Buffers.IMemoryOwner<T> — the interface itself, or a concrete type that implements
+// it? Resolved on the SYMBOL, so a fully-qualified `System.Buffers.IMemoryOwner<T>`, a type alias, or
+// a concrete owner type is recognised — not only the bare `IMemoryOwner` spelling (CodeRabbit/Codex).
+static bool IsMemoryOwnerType(ITypeSymbol? t) =>
+    t is INamedTypeSymbol nt
+    && ((nt.Name == "IMemoryOwner" && IsInNamespace(nt, "System", "Buffers"))
+        || nt.AllInterfaces.Any(i => i.Name == "IMemoryOwner" && IsInNamespace(i, "System", "Buffers")));
+
+// The owner FIELD a `Memory` view assignment aliases — `_owner.Memory` / `this._owner.Memory` of an
+// IMemoryOwner<T> field. Uses the this/bare receiver restriction (ThisFieldName), so `other._owner.
+// Memory` (another instance's owner) is NOT recorded and the this-qualified spelling IS (Codex). The
+// borrow is recognised by the resolved `IMemoryOwner<T>.Memory` property symbol, not by name.
+static string? FieldViewOwner(ExpressionSyntax e, SemanticModel model) =>
+    e is MemberAccessExpressionSyntax { Name.Identifier.Text: "Memory" } mem
+    && model.GetSymbolInfo(mem).Symbol is IPropertySymbol { ContainingType: { Name: "IMemoryOwner" } ict }
+    && IsInNamespace(ict, "System", "Buffers")
+        ? ThisFieldName(mem.Expression)
+        : null;
+
 // The tracked owner buffer a FULL-LENGTH view spans, else null. POOL005: `buf.AsSpan()` /
 // `buf.AsMemory()` with NO arguments span `[0, Length)` — the WHOLE backing array — and so does
 // `buf.AsSpan(0, buf.Length)` / `new Span<T>(buf, 0, buf.Length)`, whose length argument is the
@@ -1991,8 +2010,14 @@ or ImplicitObjectCreationExpressionSyntax
             {
                 if (fd.Modifiers.Any(mm => mm.IsKind(SyntaxKind.StaticKeyword)))
                     continue;
+                // IDisposable is matched syntactically (so a project's own unresolved `…Stream` etc.
+                // still counts); IMemoryOwner is matched on the resolved SYMBOL so a qualified
+                // `System.Buffers.IMemoryOwner<T>` / alias / concrete owner type counts too (CodeRabbit/
+                // Codex). The cheap `StartsWith` short-circuits the common unqualified spelling first.
                 var ftype = fd.Declaration.Type.ToString();
-                if (!IsDisposableType(ftype) && !ftype.StartsWith("IMemoryOwner", StringComparison.Ordinal))
+                if (!IsDisposableType(ftype)
+                    && !ftype.StartsWith("IMemoryOwner", StringComparison.Ordinal)
+                    && !IsMemoryOwnerType(model.GetTypeInfo(fd.Declaration.Type).Type))
                     continue;
                 foreach (var v in fd.Declaration.Variables)
                     dispoFieldLine[v.Identifier.Text] = LineOf(v);
@@ -2024,8 +2049,8 @@ or ImplicitObjectCreationExpressionSyntax
                 var viewFieldOwner = new Dictionary<string, string>(StringComparer.Ordinal);
                 foreach (var a in assigns)
                     if (a.IsKind(SyntaxKind.SimpleAssignmentExpression)
-                        && FieldName(a.Left) is { } vf
-                        && ViewOwner(a.Right, model) is { } vo)
+                        && ThisFieldName(a.Left) is { } vf
+                        && FieldViewOwner(a.Right, model) is { } vo)
                         viewFieldOwner[vf] = vo;
 
                 // handler method names that are LIVE subscription targets. `+=` subscriptions are