Para fazer com que a opção 2 funcione corretamente, precisamos implementar uma lista encadeada duplamente, onde cada nó aponta para o próximo e para o anterior nó na lista. Atualmente, o código só usa um ponteiro para o nó anterior, então não é possível percorrer a lista do primeiro para o último nó.

Primeiro, vamos corrigir a estrutura da lista para suportar a lista duplamente encadeada. Em seguida, vamos ajustar as inserções e a exibição dos nós para que possamos percorrer a lista em ambas as direções.

Aqui está a versão corrigida do código:

```c
#include <stdio.h>
#include <stdlib.h>
#include <locale.h>

struct funcionario {
    int matricula;
    char nome[20];
    struct funcionario *anterior;
    struct funcionario *proximo;
};

int main() {
    setlocale(LC_ALL, "Portuguese");
    int opc;
    struct funcionario *head = NULL;  // Ponteiro para o primeiro elemento da lista
    struct funcionario *tail = NULL;  // Ponteiro para o último elemento da lista

    do {
        system("cls");
        printf("O que deseja fazer:\n");
        printf("1 - Inserir\n");
        printf("2 - Listar\n");
        printf("3 - Editar\n");
        printf("4 - Remover\n");
        printf("5 - Sair\n\n");
        printf("Opção: ");
        scanf("%d", &opc);
        system("cls");

        switch (opc) {
            case 1: {
                printf("Novo funcionário\n\n");

                struct funcionario *novo = (struct funcionario *) malloc(sizeof(struct funcionario));

                printf("Digite a matricula: ");
                scanf("%d", &novo->matricula);

                printf("Digite o nome.....: ");
                scanf(" %[^\n]", novo->nome);

                novo->anterior = tail;
                novo->proximo = NULL;

                if (tail != NULL) {
                    tail->proximo = novo;
                } else {
                    head = novo;
                }

                tail = novo;

                printf("\nFuncionário cadastrado com sucesso!");

                break;
            }
            case 2: {
                int opt;
                printf("Como gostaria de ver os registros:\n\n");
                printf("1 - Do último para o primeiro\n");
                printf("2 - Do primeiro para o último\n\n");
                printf("Opção: ");
                scanf("%d", &opt);

                printf("Funcionários cadastrados\n\n");

                if (opt == 1) {
                    struct funcionario *funcAtual = tail;
                    while (funcAtual != NULL) {
                        printf("RA..: %d\n", funcAtual->matricula);
                        printf("NOME: %s\n\n", funcAtual->nome);
                        funcAtual = funcAtual->anterior;
                    }
                } else if (opt == 2) {
                    struct funcionario *funcAtual = head;
                    while (funcAtual != NULL) {
                        printf("RA..: %d\n", funcAtual->matricula);
                        printf("NOME: %s\n\n", funcAtual->nome);
                        funcAtual = funcAtual->proximo;
                    }
                } else {
                    printf("Opção inválida!\n");
                }

                break;
            }
            case 3: {
                printf("Editar funcionário\n\n");
                int matricula;
                printf("Digite a matricula: ");
                scanf("%d", &matricula);

                struct funcionario *funcAtual = head;
                while (funcAtual != NULL) {
                    if (matricula == funcAtual->matricula) {
                        printf("Nome anterior: %s\n", funcAtual->nome);
                        printf("Digite o novo nome: ");
                        scanf(" %[^\n]", funcAtual->nome);
                        printf("Nome alterado com sucesso!");
                        break;
                    }
                    funcAtual = funcAtual->proximo;
                }
                if (funcAtual == NULL) {
                    printf("Matricula não encontrada!");
                }

                break;
            }
            case 4: {
                printf("Excluir funcionário\n\n");
                int matricula;
                printf("Digite a matricula: ");
                scanf("%d", &matricula);

                struct funcionario *funcAtual = head;
                while (funcAtual != NULL) {
                    if (matricula == funcAtual->matricula) {
                        printf("Funcionário removido: %s\n", funcAtual->nome);

                        if (funcAtual->anterior != NULL) {
                            funcAtual->anterior->proximo = funcAtual->proximo;
                        } else {
                            head = funcAtual->proximo;
                        }

                        if (funcAtual->proximo != NULL) {
                            funcAtual->proximo->anterior = funcAtual->anterior;
                        } else {
                            tail = funcAtual->anterior;
                        }

                        free(funcAtual);
                        break;
                    }
                    funcAtual = funcAtual->proximo;
                }
                if (funcAtual == NULL) {
                    printf("Matricula não encontrada!");
                }

                break;
            }
            case 5: {
                printf("By... see you later :-)\n\n");
                break;
            }
            default:
                printf("Opção inválida!!!\n");
        }
        system("pause>>null");
    } while (opc != 5);

    // Liberar memória ao sair
    struct funcionario *funcAtual = head;
    while (funcAtual != NULL) {
        struct funcionario *prox = funcAtual->proximo;
        free(funcAtual);
        funcAtual = prox;
    }

    return 0;
}
```

As alterações principais feitas no código são:

1. Modificação da estrutura `funcionario` para incluir um ponteiro `proximo`.
2. Introdução de dois ponteiros, `head` e `tail`, para apontar para o início e o fim da lista, respectivamente.
3. Alteração na lógica de inserção para ajustar os ponteiros `proximo` e `anterior` corretamente.
4. Implementação de uma exibição de registros para percorrer a lista tanto do primeiro para o último quanto do último para o primeiro.
5. Ajustes na remoção de funcionários para manter a integridade dos ponteiros da lista duplamente encadeada.
6. Liberação da memória alocada ao sair do programa.

Com essas alterações, a opção 2 funcionará conforme o esperado, permitindo listar os funcionários em ambas as