Add type parameters to derived record name

modules/generic/src/main/scala-2/vulcan/generic/package.scala

@@ -56,12 +56,15 @@ package object generic {
         val param = caseClass.parameters.head
         param.typeclass.imap(value => caseClass.rawConstruct(List(value)))(param.dereference)
       } else {
+        def recursiveShortNames(typeName: TypeName): Seq[String] = {
+          typeName.short +: typeName.typeArguments.flatMap(recursiveShortNames)
+        }
 
         Codec
           .record[A](
             name = caseClass.annotations
               .collectFirst { case AvroName(namespace) => namespace }
-              .getOrElse(caseClass.typeName.short),
+              .getOrElse(recursiveShortNames(caseClass.typeName).mkString("__")),
             namespace = caseClass.annotations
               .collectFirst { case AvroNamespace(namespace) => namespace }
               .getOrElse(caseClass.typeName.owner),

modules/generic/src/main/scala-3/vulcan/generic/package.scala

@@ -28,12 +28,16 @@ package object generic {
   ) extends Derivation[Codec] {
     inline def derive[A](using Mirror.Of[A]): Codec[A] = derived[A]
 
-    final def join[A](caseClass: CaseClass[Codec, A]): Codec[A] = 
+    final def join[A](caseClass: CaseClass[Codec, A]): Codec[A] = {
+      def recursiveShortNames(typeInfo: TypeInfo): Seq[String] = {
+        typeInfo.short +: typeInfo.typeParams.toSeq.flatMap(recursiveShortNames)
+      }
+
       Codec
           .record[A](
             name = caseClass.annotations
               .collectFirst { case AvroName(namespace) => namespace }
-              .getOrElse(caseClass.typeInfo.short),
+              .getOrElse(recursiveShortNames(caseClass.typeInfo).mkString("__")),
             namespace = caseClass.annotations
               .collectFirst { case AvroNamespace(namespace) => namespace }
               .getOrElse(caseClass.typeInfo.owner),
@@ -68,6 +72,7 @@ package object generic {
               }
               .map(caseClass.rawConstruct(_))
           }
+    }
 
     final def split[A](sealedTrait: SealedTrait[Codec, A]): Codec.Aux[Any, A] = {
       Codec

modules/generic/src/test/scala/vulcan/generic/GenericDerivationCodecSpec.scala

@@ -69,6 +69,18 @@ final class GenericDerivationCodecSpec extends CodecBase {
             }
           }
 
+          it("should append types classes in record name") {
+            assertSchemaIs[CaseClassTypeClass[String]] {
+              """{"type":"record","name":"CaseClassTypeClass__String","namespace":"vulcan.generic.examples","fields":[{"name":"value","type":["null","string"]}]}"""
+            }
+          }
+
+          it("should ignore type class names with annotation for record name") {
+            assertSchemaIs[CaseClassTypeClassAvroName[String]] {
+              """{"type":"record","name":"CaseClassOtherName","namespace":"vulcan.generic.examples","fields":[{"name":"value","type":["null","string"]}]}"""
+            }
+          }
+
         }
 
         describe("encode") {

modules/generic/src/test/scala/vulcan/generic/examples/CaseClassTypeClass.scala

@@ -0,0 +1,10 @@
+package vulcan.generic.examples
+
+import vulcan.Codec
+import vulcan.generic._
+
+final case class CaseClassTypeClass[A](value: Option[A])
+
+object CaseClassTypeClass {
+  implicit val codecString: Codec[CaseClassTypeClass[String]] = Codec.derive
+}

modules/generic/src/test/scala/vulcan/generic/examples/CaseClassTypeClassAvroName.scala

@@ -0,0 +1,11 @@
+package vulcan.generic.examples
+
+import vulcan.Codec
+import vulcan.generic._
+
+@AvroName("CaseClassOtherName")
+final case class CaseClassTypeClassAvroName[A](value: Option[A])
+
+object CaseClassTypeClassAvroName {
+  implicit val codecString: Codec[CaseClassTypeClassAvroName[String]] = Codec.derive
+}