No, your $L$ (which is sometimes called $\text{REC}$) is $\Sigma_3^0$-complete. However, this proof is somewhat technical. If you just want to show that it and its complement is not c.e., there is a fairly easy proof:
It well known that $K = \{e : \Phi_e(e) \downarrow\}$ is c.e. and but not computable. ($K$ is a variant of the Halting Problem.) It is easy to show that if a set and its complement is c.e., then it must be computable. Hence the complement of $K$, denoted $\bar{K}$, is not c.e.
Define
$\Psi(e,x) = \begin{cases}
0 & \quad \Phi_{e,x}(e)\uparrow \\
0 & \quad \Phi_{e,x}(e) \downarrow \wedge (\exists s)\Phi_{x,s}(x)\downarrow \\
\uparrow & \quad \Phi_{e,x}(e) \downarrow \wedge \Phi_{x}(x)\uparrow
\end{cases}$
$\Psi$ is clearly a partial computable function. By the s-m-n theorem, there exists a computable $f$ such that $\Psi(e,x) = \Phi_{f(e)}(x)$. Thus if $e \in \bar{K}$, then $\Psi(e,x) = \Phi_{f(e)}(x) = 0$ for all $x$ so $W_{f(e)} = \omega$. $\omega$ is computable. So $f(e) \in L$. If $x \in K$, then there is a least $M$ such that $\Phi_{e,M}(e) \downarrow$. So then for all $x > M$, $\Psi(e,x)\downarrow = \Phi_{f(e)}(x)\downarrow$ if and only if $x \in K$. So $W_{f(e)}$ is equal to $K$ except for a finite difference. Since $K$ is not computable, $W_{f(e)}$ is also not computable. Hence $f(e) \notin L$. Thus it has been shown $f$ is the reduction of $\bar{K} \leq_m L$. Since $\bar{K}$ is not c.e., $L$ can not be c.e.
To show that the complement $\bar{L}$ is not c.e. Use
$$\Psi(e,x) = \begin{cases}
0 & \quad \Phi_{e,x}(e) \uparrow \wedge (\exists s)\Phi_{x,s}(x)\downarrow \\
\uparrow & \quad \Phi_{e,x}(e)\uparrow \wedge \Phi_x(x)\uparrow \\
0 & \quad \Phi_{e,x}(e)\downarrow
\end{cases}$$
By a similar argument as above, $\bar{K} \leq_m \bar{L}$. Hence $\bar{L}$ can not be c.e. either.
It has been shown that $L$ and $\bar{L}$ is not c.e.
The basic idea is: The set $K = \{\langle M \rangle : M(\langle M \rangle) \text{ halt }\}$ is recognizable but not decidable. Hence its complement $\bar{K} = \{\langle M \rangle : M(\langle M \rangle) \text{ does not halt}\}$ is not recognizable.
Let $M_x$ denote the Turing machine with code $x$. You want to construct a Turing machine $U$ that reduces $\bar{K}$ to $L$. Given $M$ define $T_M$ to the be Turing machine such that:
$T_M(x)$ halts if $M(\langle M \rangle)$ does not halt by stage $x$
$T_m(x)$ halts if $M(\langle M \rangle)$ halts by stage $x$ and $M_x(x)$ eventually halts
$T_M$ does not halt otherwise
Let $U(\langle M \rangle) = \langle T_M \rangle$
Then if $\langle M \rangle \in \bar{K}$, $T_M$ halts on all input. Hence $L(T_M)$ is decidable. So $U(M) = \langle T_M \rangle \in L$ If $\langle M \rangle \notin \bar{K}$, then $L(T_M)$ agrees with $K$ except on a finite set. Since $K$ is not decidable, $L(T_M)$ is not decidable. So $U(M) = \langle T_M \rangle \notin L$. This give the reduction of $\bar{K} \leq L$. Since $\bar{K}$ is not recognizable, $L$ is not either.
Using a similar idea, you can reduce $\bar{K} \leq \bar{L}$, where $\bar{L}$ is the complement of $L$.
It suffices to focus on the case $\Sigma = \{0,1\}$. We argue that $ALL_{\textsf{minCFG}} \leq_T MIN_{\textsf{CFG}}$. That is, we can determine whether a minimal CFG can generate all possible strings, by using the oracle for $MIN_{\textsf{CFG}}$.
Let $G$ denote the minimal CFG we are interested. Since $G$ is minimal, there exists a length $p$ such that, for each rule $R$ in $G$ there exists a string $w_R$ with $|w_R|<p$ that can be generated by $G$, but not with $R$ deleted.
Note here that $p$ is computable in a brute force manner.
Construct $G^+_{a_1a_2\cdots a_p}$ where $a_i \in \Sigma$, by adding following rules in $G$:
$$
S \to a_1 a_2 \cdots a_pT \\
T \to T0 \ | \ T1 \ | \ \epsilon
$$
First, consider what will happen if $G^+_{a_1a_2\cdots a_p}$ is not minimal, thus, there exists a rule $R$ in $G^+$ being dispensable. By our construction it is clear that each rule $R$ in $G$ is indispensable.
- If $S \to a_1 a_2 \cdots a_pT$ or $T \to \epsilon$ is dispensable, then we have $a_1 a_2 \cdots a_p \Sigma^* \subseteq L(G)$.
- If $T \to T0$ is dispensable, then we have $(a_1 a_2 \cdots a_p \Sigma^* - a_1 a_2 \cdots a_p 1^*) \subseteq L(G)$. Because whether $a_1 a_2 \cdots a_p1^* \subseteq L(G)$ is easy to determine by some classical algorithm, we can also determine whether $a_1 a_2 \cdots a_p \Sigma^* \subseteq L(G)$.
- It is similar for $T \to T1$.
Therefore, if $G^+_{a_1a_2\cdots a_p}$ is not minimal, we can determine whether $a_1 a_2 \cdots a_p \Sigma^* \subseteq L(G)$. What if it is minimal? In this case we will immediately know $L(G) \neq \Sigma^*$. So we can suppose that all possible $G^+_{a_1a_2\cdots a_p}$ is not minimal. Then by checking whether $a_1 a_2 \cdots a_p \Sigma^* \subseteq L(G)$ one by one and checking those strings of less-than-$p$ length, we can still decide whether $L(G) = \Sigma^*$.
Update. (Oct 12, 2020) After a short discussion with @xdavidliu I realized that the argument above can directly prove what we want, without a justification of uncomputability of $ALL_{\textsf{minCFG}}$. Recall that the reduction we have established achieves the following: Given a minimal CFG $G$, determine whether $L(G) = \Sigma^*$. Now if we want to decide whether $L(G_0) = \Sigma^*$ for an arbitrary CFG $G_0$, just simply feed into the (reduction) algorithm all minimal sub-CFG (test each sub-CFG by the $MIN_{\mathsf{CFG}}$ oracle to determine whether it is minimal) of $G_0$ and see if there is one that generates all strings.
Since this problem appears in Chapter 5, in which Turing reduction has not introduced. I personally believe that there is an elegant proof using only mapping reduction.
Update. @Sylvain gives an elegant proof on https://cstheory.stackexchange.com/a/39454/46760, by showing
$$ PCP \leq_T FullPCP \leq_m MIN_{\textsf{CFG}}$$
in which I personally thought the key is that context-free language is closed under $h^{-1}$ he defined.
Best Answer
There is a helpful construction for this type of problems
This problem asks you to use this construction to show that AMBIGcfg is undecidable
Hopefully you can see that T generates a string from the upper strings and B generates a string from the lower strings
The terminals at the end encode the sequence of "dominos" used , so if T generates a string (assume that the alphabet for this PCP Instance is {a,b}) : aaab12 and B generates a string aaab12 , then a match was found , that is because we formed the match aaab using the same sequence of dominos 12 (here we use domino 2 then 1 think about it !) , this encoding guarantees that both T which uses the upper strings and B which uses the lower strings have used dominos in the same order when they formed the match
A further example to emphasis the idea , assume we use T --> t1 T a1 , then use T --> t2 a2 we generate the string t1 t2 a2 a1 , the string generated by dominos is t1 t2 and the sequence of dominos used is a1 then a2 , once again ,if B generates a string b1 b2 a2 a1, where b1 b2 = t1 t2 , then we found a match , since strings are the same with same sequence of dominos used , hopefully by now you understand how the construction works and are convinced that T and B generate the same string only if we have a match
In this problem , if both T and B generate the same string , the grammer is ambiguous and we accept , else we reject , deciding the PCP
Now can you tweek this construction for our problem ?
We replace S --> T|B by S -->TB , and replace every rule B --> bi B ai by B --> ai B bi , and replace every rule B --> bi ai by B --> ai bi ( reversing the strings on right side of rules which have B on left side )
If a match w exists , then T would generate w , and B would generate w^R , then TB is ww^R which is palindrome , ex : if w is aaab12 then T generates aaab12 and B generates 21baaa , so S is aaab1221baaa , which is a palindrome
I leave it you you to convince your self that the only way for a palindrome to exist is to have a match , if you consider that a match is represented in our grammer by the string followed by a unique sequence of dominos used for this string , then it should be easy to see how it works
So construct G with rules provided above , we assume that a decider R exists for L , we run L on < G> ,
If a match exists G generates some palindrome and L accepts
If a match doesn't exist , G generates no palindromes , and L rejects