Q:

Como modificar uma série de funções em Long para BigInteger?

O código abaixo verifica se um número é primo numa sequência gerada a partir de uma fórmula: 
package dec;

import java.util.ArrayList;
import java.util.List;

public class Dec {

private static boolean ehPrimo(long d) {

long n = d;
long raiz = (long) Math.sqrt(n);
for (long k = 2; k <= raiz; k++) {
    if (n % k == 0) return false;
 }
return true;
} 

public static void main(String[] args) {

List<Long> primeiraLista = new ArrayList();
List<Long> segundaLista = new ArrayList();
for (long a = 1; a <= 100; a++) {
long c = a + 69;
if (ehPrimo(c)) {
primeiraLista.add(c);
} else {
long d = c + 6;
if (ehPrimo(d)) {
    segundaLista.add(d);
  }
 }
}
System.out.printf("Primeira lista %s%n", primeiraLista);
System.out.printf("Segunda lista %s%n", segundaLista);       
 }
}

De 1 a 100 das 2 listas somente os Primos:

O único problema é que esse código esta em Long, como fazer ele todo em BigInteger para números maiores?

A:

Basicamente você precisa dividir o problema em duas partes.
1. Determinando se um número é primo
Essa é a parte já resolvida por outras questões. Com base no seu algoritmo, uma possível implementação seria:
boolean ehPrimo(long n) {
    long raiz = (long) Math.sqrt(n);
    for (long k = 2; k <= raiz; k++) {
        if (n % k == 0) return false;
    }
    return true;
}

2. Gerando a sequência numérica de acordo com as duas fórmulas
Quando você define uma fórmula ou equação, não se faz com várias linhas como você fez. Poderia ter escrita de forma muito mais simplificada.
Se b = a + 37 e c = a + b, podemos substituir b na segunda equação e obter c = a + a + 37. 
O mesmo serve para o cálculo de d, onde podemos escrever simplesmente que d = c + 8. 
Agora temos que a é a variável e podemos fazer um loop tal que a varie de 1 a 100. A cada iteração, podemos calcular os valores de c e d conforme necessário. 
Finalmente, podemos adicionar os valores de c primos numa lista e os valores de d primos em outra lista.
Exemplo de código:
List<Long> primeiraLista = new ArrayList();
List<Long> segundaLista = new ArrayList();
for (long a = 1; a <= 100; a++) {
    long c = a + a + 37;
    if (ehPrimo(c)) {
        primeiraLista.add(c);
    } else {
        long d = c + 8;
        if (ehPrimo(d)) {
            segundaLista.add(d);
        }
    }
}

Finalmente, podemos imprimir as listas como for necessário. Por exemplo:
System.out.printf("Primeira lista %s%n", primeiraLista);
System.out.printf("Segunda lista %s%n", segundaLista);

Atualização
Após a atualização da pergunta para BigInteger o código poderia ser alterado da seguinte forma:
public class StrangePrimeFormulaWithBigInteger {

    public static void main(String[] args) {
        List<BigInteger> primeiraLista = new ArrayList();
        List<BigInteger> segundaLista = new ArrayList();
        BigInteger limit = new BigInteger("100");
        BigInteger n37 = new BigInteger("37");
        BigInteger n8 = new BigInteger("8");
        for (BigInteger a = BigInteger.ONE; a.compareTo(limit) <= 0; a = a.add(BigInteger.ONE)) {
            BigInteger c = a.add(a).add(n37);
            if (ehPrimo(c)) {
                primeiraLista.add(c);
            } else {
                BigInteger d = c.add(n8);
                if (ehPrimo(d)) {
                    segundaLista.add(d);
                }
            }
        }

        System.out.printf("Primeira lista %s%n", primeiraLista);
        System.out.printf("Segunda lista %s%n", segundaLista);
    }

    public static boolean ehPrimo(BigInteger n) {
        BigInteger raiz = sqrt(n);
        for (BigInteger k = new BigInteger("2"); k.compareTo(raiz) <= 0; k = k.add(BigInteger.ONE)) {
            if (n.mod(k).equals(BigInteger.ZERO)) return false;
        }
        return true;
    }

    /**
     * Extraído de https://stackoverflow.com/a/16804098/1683070
     */
    public static BigInteger sqrt(BigInteger x) {
        BigInteger div = BigInteger.ZERO.setBit(x.bitLength()/2);
        BigInteger div2 = div;
        // Loop until we hit the same value twice in a row, or wind
        // up alternating.
        for(;;) {
            BigInteger y = div.add(x.divide(div)).shiftRight(1);
            if (y.equals(div) || y.equals(div2))
                return y;
            div2 = div;
            div = y;
        }
    }

}

Algumas considerações:

Agora as listas são com o novo tipo: List<BigInteger>.
Números precisam ser instanciados e não diretamente atribuídos: BigInteger n8 = new BigInteger("8");.
Instanciei os números 37, 8 e 100 antes do laço para evitar instanciá-los repetidamente a cada iteração.
Todas as operações matemáticas precisa usar os métodos de BigInteger como add, divide, mod (resto).
Comparações são feitas usando equals e compareTo, não ==.
a.compareTo(limit) <= 0 é o mesmo que a <= limit
O Java não disponibiliza um método para calcular a raiz desse tipo de variável. Para uma solução confiável você pode usar uma biblioteca como Apache Commons Math ou Google Guava. Neste caso eu inseri uma implementação disponibilizada em uma resposta do SOen.
Cálculos com variáveis BigInteger e BigDecimal pode chegar a várias ordens de magnitude mais lentas do que com tipos primitivos, embora nesse caso que cuja computação é bem leve essa diferença seja quase imperceptível.

