É possível recuperar atributos para um valor Enum no Delphi 12?

Infelizmente, não há como fazer o que você quer, pois não há RTTI armazenado para membros de enumeração individuais, apenas para o tipo de enumeração em si.

De acordo com esta resposta ao Delphi 2010 RTTI: Explore Enumerations (que ainda é válido para o Delphi 12):

Atributos associados a elementos em enumerações não são armazenados atualmente em dados RTTI do Win32 no executável. O RTTI já é responsável por um aumento justo no tamanho dos executáveis, então algumas linhas tiveram que ser desenhadas em algum lugar. Atributos no Delphi Win32 são suportados em tipos, em campos de registros e campos, métodos, seus parâmetros e propriedades de classes.

As declarações de atributos não causam erros devido à compatibilidade com versões anteriores do Delphi para .NET.

Então, sua solução alternativa para colocar os atributos no tipo enum e então indexá-los pelo valor enum é a melhor que você pode fazer.

Seguindo a resposta de Remy, parece não ser possível acessar Atributos de membros específicos. A maneira como consegui um resultado semelhante foi definindo um atributo como:

  MappingAttr = class(TCustomAttribute)
  private
    FValue: String;
  public
    constructor Create(const AValue: string);
    property Value: string read FValue;
  end;

E duas funções genéricas, declaradas como

  ///  <summary>
  ///   Class to hold generic functions that deal with conversion between Strings
  ///  and Mapping Enums.
  ///  </summary>
  TEnumMapping = class
  public
  ///  <summary>
  ///  Takes an enumeration value and returuns the value of the <see cref="MappingAttr"/> for that entry
  ///  </summary>
  ///  <param name="Value"><i>T</i>: Type of the enum used.</param>
    class function EnumToString<T>(const Value: T): string; static;
  ///  <summary>
  ///  Takes a string value and returns the enumeration value (index) related to that string.
  ///  For it to work there are some assumptions that will lead to exceptions if ignored, (or worse, UB)
  ///
  ///  1. The Enum has the same amount of attributes and items. (For each enumerated name there is one and only one attribute AND it has a MappingAttr type)
  ///  2. The Enum has no custom ordinality.
  ///  3. The type of the attribute mapping the Enum is MappingAttr.
  ///  </summary>
  ///
  ///
    class function StringToEnum<T>(const Value: string): T; static;
  end;

E implementado como

class function TEnumMapping.EnumToString<T>(const Value: T): string;
var
  RTTICtx: TRttiContext;
  RTTIType: TRttiType;
  RTTIEnum: TRttiEnumerationType;
  GenericValue: TValue;
  OrdValue: Int64;
begin
  RTTICtx := TRTTIContext.Create;
  try
    RTTIType := RTTICtx.GetType(TypeInfo(T));
    // Raises an exception if the type is not an enumeration.
    if (RTTIType = nil) then
      raise ETypeHasNoRTI.Create('The type has no Runtime Information');

    if (RTTIType.TypeKind <> tkEnumeration) then
      raise Exception.CreateFmt('Type %s is not an enumeration', [RttiType.Name]);

    // Creates a TValue from Value and try casting it to Ordinal
    GenericValue := TValue.From<T>(Value);
    if not GenericValue.TryAsOrdinal(OrdValue) then
      raise EInvalidCast.Create('Could not cast generic value to ordinal');

    RTTIEnum := TRTTIEnumerationType(RTTIType);
    if (OrdValue > RTTIEnum.MaxValue) or (OrdValue < RTTIEnum.MinValue) then
      raise EEnumNameNotFound.CreateFmt('%d has no valid enum name for %s', [OrdValue, RTTIType.Name]);

    var LenStore: Integer := Length(RTTIEnum.GetAttributes);
    if (LenStore = 0) or (LenStore - 1 < OrdValue) then
      raise ERTTIMappingBadFormat.CreateFmt('RTTI Mapping in %s is badly formated.', [RTTIEnum.Name]);

    exit(MappingAttr(RTTIEnum.GetAttributes()[OrdValue]).Value);
  finally
    RTTICtx.Free;
  end;

  raise ERTTIMappingNotFound.Create('No [MappingAttr(...)] found');
end;

class function TEnumMapping.StringToEnum<T>(const Value: string): T;
var
  RTTICtx: TRTTIContext;
  RTTIType: TRTTIType;
begin
  RTTICtx := TRTTIContext.Create();
  try
    RTTIType := RTTICtx.GetType(TypeInfo(T));
    // Raises an exception if the type is not an enumeration.
    if (RTTIType = nil) or (RTTIType.TypeKind <> tkEnumeration) then
      raise Exception.CreateFmt('Type %s is not an enumeration', [RttiType.Name]);

    FillChar(Result, SizeOf(Result), 0); // Set a default value

    var ItemCount, AttrCount: Integer;
    ItemCount := Length(TRTTIEnumerationType(RTTIType).GetNames());
    AttrCount := Length(RTTIType.GetAttributes());

    if (AttrCount = 0) or (ItemCount <> AttrCount) then // No Attr or different amounts
      raise ERTTIMappingBadFormat.CreateFmt('RTTI Mapping in %s is badly formated.', [RTTIType.Name]);

    var Index: Integer := 0;
    var Walks: Integer := 0;
    var Found: Boolean := False;
    for var Attr: TCustomAttribute in RTTIType.GetAttributes do
    begin
      if Attr is MappingAttr then // just in case. Should always be MappingAttr.
      begin
        Inc(Index);
        Found := MappingAttr(Attr).Value = Value;
        if Found then // Will break if the attribute value matches the search.
          break;
      end;
    end;

    if not Found then
      raise ERTTIMappingNotFound.CreateFmt('No match for %s on %s', [Value, RTTIType.Name]);

    // Casts the address of result to a integer pointer, deref it, assigns Index.
    PInteger(@Result)^ := Index; // if not frend why frend shaped?
    Exit(Result);
  finally
    RTTICtx.Free();
  end;

  raise Exception.Create('Something went *very* wrong.');
end;

Elas foram escritas às pressas, mas funcionaram até agora. O problema é definir todos os atributos em relação ao tipo Enum e não seus valores, então, enquanto as suposições antes das funções se mantiverem, ele será capaz de recuperar consistentemente, eu acho.