fix: percent-encode 2.x channel references written by address

AsyncApiChannelReference.SerializeV2 writes a reference to a root channel with
the channel's address, escaped with EscapeToken only. A channel addressed
"a%20b" was written as "#/channels/a%20b", which decodes to "a b" and no longer
resolves. It now uses EscapeUriFragmentToken, as does the 2.x reader when it
points such a reference at the normalized channel key.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: bielu

src/ByteBard.AsyncAPI.Readers/V2/AsyncApiChannelDeserializer.cs

@@ -67,7 +67,7 @@ private static string NormalizeChannelPointer(string pointer)
                 return pointer;
             }
 
-            return channelsPrefix + JsonPointer.EscapeToken(NormalizeChannelKey(parsed.Tokens[1]));
+            return channelsPrefix + JsonPointer.EscapeUriFragmentToken(NormalizeChannelKey(parsed.Tokens[1]));
         }
 
         public static string NormalizeChannelKey(string channelKey, ParseNode node = null)

src/ByteBard.AsyncAPI/Models/References/AsyncApiChannelReference.cs

@@ -64,7 +64,7 @@ public override void SerializeV2(IAsyncApiWriter writer)
                     // 2.x keys root channels by address instead of by key. A target the document does not write
                     // keeps its own reference, so it can be found dangling and written inline.
                     writer.WriteStartObject();
-                    writer.WriteOptionalProperty(AsyncApiConstants.DollarRef, "#/channels/" + JsonPointer.EscapeToken(this.Target.Address));
+                    writer.WriteOptionalProperty(AsyncApiConstants.DollarRef, "#/channels/" + JsonPointer.EscapeUriFragmentToken(this.Target.Address));
                     writer.WriteEndObject();
                     return;
                 }

test/ByteBard.AsyncAPI.Tests/Models/PercentEncodedReferenceKeys_Should.cs

@@ -298,12 +298,36 @@ public void V2_UpgradesToV3()
             upgraded.Operations["op"].Messages.Single().Equals(upgraded.Channels["usersignedup"].Messages["signed up"]).Should().BeTrue();
         }
 
+        // 2.x keys channels by address, so a reference to a root channel is written with its encoded address.
+        [TestCase("a b", "a%20b")]
+        [TestCase("a%20b", "a%2520b")]
+        public void V2_ChannelReference_RoundTripsByEncodedAddress(string address, string encodedAddress)
+        {
+            var yaml =
+                $"""
+                asyncapi: 2.6.0
+                info:
+                  title: test
+                  version: 1.0.0
+                channels:
+                  {address}:
+                    description: target
+                  other:
+                    $ref: '#/channels/{encodedAddress}'
+                """;
+
+            var actual = Read(yaml).SerializeAsYaml(AsyncApiVersion.AsyncApi2_0);
+
+            actual.Should().BePlatformAgnosticEquivalentTo(yaml);
+            Read(actual).Channels["other"].Description.Should().Be("target");
+        }
+
         private static AsyncApiDocument Read(string yaml)
         {
             var doc = new AsyncApiStringReader().Read(yaml, out var diagnostic);
 
             // The keys fail the spec's key patterns; anything else means a reference did not resolve.
-            diagnostic.Errors.Should().OnlyContain(e => e.Message.Contains("MUST match the regular expression"));
+            diagnostic.Errors.Where(e => !e.Message.Contains("MUST match the regular expression")).Should().BeEmpty();
             return doc;
         }
     }