As the original paper is showing a lot more, I use this one at page 69-70, Theorem 3.9, as this is the proof I also know.
As you can see there, the complete statement of Baker, Gill, Solovay is:
There exist oracles $A, B$ s.t. $P^A = NP^A$ and $P^B \neq NP^B$
The second oracle cannot be considered a counterexample for $P = NP$ because you cannot "divide" by B so to say. Constructing a oracle language $L^A$ out of a "normal" language $L$ is not that easy. The languages $P^B$ and $NP^B$ behave completely different than $P$ and $NP$. To show you an example for this: Even if $P=NP$ is true, the statement $P^B \neq NP^B$ is still valid. This shows how different $P,NP$ and $P^B, NP^B$ behave.
It seems to me that we have constructed a language recognizable in NP time but not in P time.
Be careful here. It is shown that unary language $U_B$ can be recognized by a $NP^B$-TM, not by a $NP$-TM. Again, this is because Oracle-Languages/TMs behave completely different than their "normal" counterparts. If you want to recognize $U_B$ in $NP$ without the oracle, you have to do a lot more work as you could guess a word $w$ of length $i$ in poly. time, but you cannot decide $w \in B$ that easy, as we have no clue by BGS if $B \in NP$ or not.
And if it is not, can it be strengthened into one?
Maybe yes, maybe not. As this would solve $P=NP?$, which is unknown, it is unknown if you could strengthen it or not.
In the proof there is the sentence "If $P_i^{B(i)}$ accepts $0^n$, then place no string into B at this stage." How can this possibly happen?
As you just simulate all TMs in $P_i^{B(i)}$ and don't change them, you cannot change whether the TM accepts or not. For example, the TM that accepts all words is in $P$, so it also is in $P^B$, so it will be simulated at some point. Then, your case will happen. Of course, this TM will not call the oracle once.
Edit 3:
Now I want to convince you that your Algorithm does not run in $NP$-time. I can't convince you by now that really $B \not \in NP$, but I think I can convince you now at least that this algorithm does not gives us $B \in NP$.
Let's try to formulate your algorithm as an $NP$-TM that decides $w \in B$ (using original BGS, Theorem 3 now):
Guess $i$ s.t. $M_i^B(1^{|w|})$ is the poly-TM where $n:=|w|$ is choosen. See that $M_i$ has access to oracle $B$. Guessing $i$ is possible because $i\leq n$ as each stage needs a unique $n$. However, can we verify that $i$ is right? To do so, we might have to really build $B$ from stage $i=0$, which would take to long.
2. Simulate $M_i(1^{|w|})$ for $2^n/10$ time. I'm not sure whether we can do this. We don't know if $M_i$ is a poly-time TM, so we can't really guess a polynomial $p : \mathbb{N} \rightarrow \mathbb{N}$ so it could really run for $2^n/10$ time as we enumerate all TM's so e.g. also the $EXP$-hard ones. Can you find a fix for this? If so, I will re-edit this answer to describe the next steps. Using original BGS now:
Simulate $M_i^B(1^{|w|})$ for $p(|w|)$ time. We can guess the polynomial $p$ in $NP$-time. However, can we verify that $p$ is the right polynomial? We cannot assume that it's right and I can't find an easy way to do this. But here comes the problem: Can we really simulate $M_i^B(1^{|w|})$ in poly. time? I want to convince you that this is not the case.
2.1. If $M_i^B(1^{|w|})$ writes $x_B$ on the oracle tape and asks $x_B \in B?$, what can we do in $NP$ without the oracle? We can only start another simulation, guess another $i'$ s.t. stage $i'$ takes $n':=|x_B|$ and simulate $M_{i'}^B(1^{|x_B|})$.
However, how many such new simulations do we have to do in the worst case? $M_i^B(1^{|w|})$ with running time $p(|w|)$ could ask the oracle $p(|w|)$ questions of length $p(|w|)$. Let's look at some arbitrary question at step $j$ now. Let the asked question in step $j$ be $x_B \in B?$. Now, we have to guess $i'$ s.t. $n':=|x_B|$ and simulate $M_{i'}^B(1^{|x_B|})$. Let $p'(|x_B|)$ be the running time of $M_{i'}^B(1^{|x_B|})$. Now, in the worst case, $M_{i'}^B(1^{|x_B|})$ asks the oracle $B$ in every of the $p'(|x_B|) = p'(p(|w|))$ steps again a question of length $p'(|x_B|) = p'(p(|w|))$. And this can go on and on.
In the end, we have build a tree with the vertex degree being $O(p''(|w|))$ for some polynomial $p''$. The depth of this tree can be pretty huge, because $i$ could equal $i'$. Let's assume just for simplicity that in each step $j$ we asked each stage $k \in \{1,\cdots,n\}$ exactly one question. Then we have depth $n$ for each path from the root to some leaf in the tree. Therefore, to answer the initial question $w \in B?$, we have to look at each of the $O(p''(|w|))^n$ verticies. Clearly, this can only be done in exponentioal time and not in polynomial time, because we have a exponention number of vertecies w.r.t $|w|$. Therefore, the algorithm does not run in $NP$-time.
