Better support for protobuf enum prefixes

[Krever]

Checklist

• I read the documentation at https://chimney.readthedocs.io/ and checked that the functionality doesn't exist
• x] I checked the https://github.com/scalalandio/chimney/issues and haven't found the feature already requested reported
• I confirmed that the request is not related to functionality that was deprecated: lifted transformers (TransformerFs) or unsafeOption flags
• I believe that this is actual feature request, rather than a question how to use existing features

Describe the desired behavior

There is a convention in defining protobuf enums to prefix them. See here for more details.

It should be easier to handle that use case.

On solution could be for Chimney to provide a name comaprison strategy like this:

case object ProtobufPrefixStripping extends TransformedNamesComparison {

    def namesMatch(fromName: String, toName: String): Boolean = toName.endsWith(fromName.toUpperCase)
      
}

Use case example

• (Let me know if not obvious and I will fill it)

How it relates to existing features

This is currently possible but defining the comaprison strategy in user-space. It is rather invonvenient due to the "upstream module requirement" - name comparison code has to be compiled before usage.

Additional context

There might be other solutions to this problem. The end goal is to improve the support for this use case. The proposed solution is just one idea.

[MateuszKubuszok]

So the issue is that the core library should have no external dependencies nor library-specific conventions - libraries come-and-go so any solution in core library would be something can can be easily adapted to other libraries, cases etc.

Situation where there is a bunch of types, where each of them has a prefix to strip, and these prefixes are different for each type, is rather uncommon. If one had to define something per each such enum transformation them we might as well create a dedicated PB enum macro in Protobuf integration:

def defineEnumTransformer[Domain, Protobuf]("prefix_to_add"): Transformer[Domain, Protobuf]

def defineEnumPartialTransformer[Protobuf, Domain]("prefix_to_drop"): PartialTransformer[Protobuf, Domain]

Perhaps, such a macro could be smart enough to figure out what prefix to drop on its own since it would know the context: which side is PB with come convenction, which side it not, and what the convention is. Which cannot be assumed in advance in a general case.