With ReferenceHandler.IgnoreCycles, registering the factory changes serialized output when a cycle passes through an unclaimed (polymorphic) ancestor #90

What's wrong

JsonRequiredConditionallyConverter.Write (JsonRequiredConditionally/JsonRequiredConditionallyConverter.cs:104-105) calls JsonSerializer.Serialize(writer, value, plainOptions). That starts a fresh serialization with its own reference/cycle tracker.

• When the claimed type is the root, this does no harm, because everything below it is written by that one inner call.
• When a claimed type sits below an unclaimed ancestor, the inner call cannot see the ancestor, so IgnoreCycles no longer cuts the cycle where it would without the factory. By design that happens with polymorphic types (the README says they are not claimed), and with root collections until Deserializing a top-level List<T>/T[]/Dictionary<string,T> of a decorated type reports only the first violation, with no index (Tuning instead of [0].Tuning, [2].Tuning) #50 / PR Report every failing element of a root list, array or dictionary [patch] #87 lands.

SerializerFeatureGuard.cs:113-115 and the README both present IgnoreCycles as supported, writing null where a cycle would close.

Repro

All runs use options with ReferenceHandler = ReferenceHandler.IgnoreCycles.

public class Node
{
    public string? Kind { get; set; }
    [JsonRequiredIfSiblingIs(nameof(Kind), "A")] public string? Tuning { get; set; }
    public List<Node>? Children { get; set; }
    public PolyBase? Owner { get; set; }
}
[JsonDerivedType(typeof(PolyDerived), "d")] public class PolyBase { public Node? N { get; set; } }
public class PolyDerived : PolyBase { }

var p = new PolyBase();
p.N = new Node { Kind = "B", Owner = p };
JsonSerializer.Serialize(p, options);

Polymorphic ancestor

Root list. Here l = [a] and a.Children = l.

I reproduced both on net10.0 against HEAD b518593. PR #87 will probably fix the root-list case. The polymorphic case remains.

Why it matters

Registering a validation library should not change the JSON it writes. Here it silently adds a level of nesting and moves where the cycle is cut. Anything that compares, hashes, or round-trips the output sees different results depending on whether the factory is registered. The existing test ContainmentTests.IgnoreCyclesSerializesACyclicGraphThroughAClaimedType (ContainmentTests.cs:119) only covers a cycle rooted at the claimed type.

Suggested fix / acceptance criteria

One of:

• Write in a way that keeps the outer write stack's cycle detection, for example by serializing with the caller's options and a JsonTypeInfo obtained from plainOptions. Whether System.Text.Json allows this needs checking. Or:
• Document in the README's IgnoreCycles paragraph that a cycle crossing an unclaimed ancestor is cut one level later.

Tests: either the polymorphic repro above serializes the same with and without the factory, or the README states the limitation.