Haskell - 481 405 bytes

import Data.List
s&t=elemIndices s t
l=last
b a=(([id,reverse]<*>[a]>>=).)
c!(x:y:z)=l$(y:c)!(x:z):((!)[].(:c++z)<$>b x(b y)(\(x:p)q->[q++p]<*x&[l q]))
c!(x:[])=x:[]!c
c!z=z
main=interact(\m->let{g=' '&m;
u=(\\[k|k<-g,length(k&concat v)==2])<$>[]!v;
v=[[x,y]|x<-g,y<-g,elem(y-x-1)[0,head$'\n'&m]];
}in '|':(u>>=(++"|").init.(>>=(:" ").toEnum.((+)<*>(+65).(*32).(`div`26)).l.(-1:).(&(nub$u>>=init.tail)))))

This gets the list of spaces that are in the maze (numbered by index in the string) uses it to find all the pairs of adjacent spaces. It then stitches the pairs together into longer sequences of points based on matching first/last elements and removes the ones corresponding to corridors so that each sequence is one room in the 1D maze. A pairing between letters and points on the interior of these rooms (the warp points) is created and used to translate the lists of numbers into a string, which is the output.

The 2D maze is read from STDIN and the 1D maze is printed to STDOUT.

Edit: Reduced by 62 bytes rearranging a bunch of stuff and modifying the algorithm a bit, and another 14 by replacing chr with toEnum as suggested by Laikoni.

Haskell - 481 405 387 bytes

import Data.List
s&t=elemIndices s t
l=last
c!(x:y:z)=l$(y:c)!(x:z):do{[x:p,q]<-mapM([id,reverse]<*>)[[x],[y]];x&[l q];[[]!((q++p):c++z)]}
c![x]=x:[]!c
c!z=z
main=interact(\m->let{g=' '&m;
u=(\\[k|k<-g,length(v>>=(k&))==2])<$>[]!v;
v=[[x,y]|x<-g,y<-g,elem(y-x-1)[0,head$'\n'&m]];
}in '|':(u>>=(++"|").init.(>>=(:" ").toEnum.((+)<*>(+65).(*32).(`div`26)).l.(-1:).(&(nub$u>>=init.tail)))))

This creates a list of spaces that are in the maze, numbered by index in the string, and uses it to find all the pairs of adjacent spaces. It then stitches the pairs together into longer sequences of points based on matching first/last elements and removes the corridors, so that each sequence is one room in the 1D maze. The sequences are then translated into a string by replacing points on the interior of at least one room (the warp points) into corresponding letters and the rest into spaces.

The 2D maze is read from STDIN and the 1D maze is printed to STDOUT.

Edit: Reduced by 62 bytes rearranging a bunch of stuff and modifying the algorithm a bit, and another 14 by replacing chr with toEnum as suggested by Laikoni.

Edit 2: Saved 13 more bytes by simplifying the logic in (!), 3 by using the list pattern match sugar, and 2 by using >>= to concat in u.

Haskell - 481 bytes

import Data.List
import Data.Char
e=elemIndices
o(x:p)q
 |x==last q=[q++p]
 |1>0=[]
b a=(([id,reverse]<*>[a]>>=).)
c!(x:y:z)=last$(y:c)!(x:z):((!)[].(:c++z)<$>(b x)(b y)o)
c!(x:[])=x:[]!c
c!z=z
main=interact(\m->let{n:_=e '\n'm;
g=e ' 'm;
j k=[k+d|d<-[1,n+1,-1,-n-1],elem(k+d)g];
k#x
 |d:[]<-j k\\[x]=d#k
 |1>0=k;
u=[]!nub[sort[k,l]|k<-g,(length.j)k>2,l<-(#k)<$>j k];
v=zip(nub$u>>=init.tail)$[65..90]++[96..122]
}in '|':(u>>= \r->init(r>>= \s->maybe ' 'chr(lookup s v):" ")++"|"))

This gets the list of spaces that are in the maze (numbered by index in the string) and walks down the corridors from each junction to create a list of pairs of dead ends and junctions in the maze which are directly connected by corridors. It then stitches the pairs together into longer sequences of points based on matching first/last elements, so that each sequence is one room in the 1D maze. A pairing between letters and points on the interior of these rooms (the warp points) is created and used to translate the lists of numbers into a string, which is the output.

The 2D maze is read from STDIN and the 1D maze is printed to STDOUT.

Haskell - 481 405 bytes

import Data.List
s&t=elemIndices s t
l=last
b a=(([id,reverse]<*>[a]>>=).)
c!(x:y:z)=l$(y:c)!(x:z):((!)[].(:c++z)<$>b x(b y)(\(x:p)q->[q++p]<*x&[l q]))
c!(x:[])=x:[]!c
c!z=z
main=interact(\m->let{g=' '&m;
u=(\\[k|k<-g,length(k&concat v)==2])<$>[]!v;
v=[[x,y]|x<-g,y<-g,elem(y-x-1)[0,head$'\n'&m]];
}in '|':(u>>=(++"|").init.(>>=(:" ").toEnum.((+)<*>(+65).(*32).(`div`26)).l.(-1:).(&(nub$u>>=init.tail)))))

This gets the list of spaces that are in the maze (numbered by index in the string) uses it to find all the pairs of adjacent spaces. It then stitches the pairs together into longer sequences of points based on matching first/last elements and removes the ones corresponding to corridors so that each sequence is one room in the 1D maze. A pairing between letters and points on the interior of these rooms (the warp points) is created and used to translate the lists of numbers into a string, which is the output.

The 2D maze is read from STDIN and the 1D maze is printed to STDOUT.

Edit: Reduced by 62 bytes rearranging a bunch of stuff and modifying the algorithm a bit, and another 14 by replacing chr with toEnum as suggested by Laikoni.

Haskell - 481 bytes

import Data.List
import Data.Char
e=elemIndices
o(x:p)q
 |x==last q=[q++p]
 |1>0=[]
b a=(([id,reverse]<*>[a]>>=).)
c!(x:y:z)=last$(y:c)!(x:z):((!)[].(:c++z)<$>(b x)(b y)o)
c!(x:[])=x:[]!c
c!z=z
main=interact(\m->let{n:_=e '\n'm;
g=e ' 'm;
j k=[k+d|d<-[1,n+1,-1,-n-1],elem(k+d)g];
k#x
 |d:[]<-j k\\[x]=d#k
 |1>0=k;
u=[]!nub[sort[k,l]|k<-g,(length.j)k>2,l<-(#k)<$>j k];
v=zip(nub$u>>=init.tail)$[65..90]++[96..122]
}in '|':(u>>= \r->init(r>>= \s->maybe ' 'chr(lookup s v):" ")++"|"))

This gets the list of spaces that are in the maze (numbered by index in the string) and walks down the corridors from each junction to create a list of pairs of dead ends and junctions in the maze which are directly connected by corridors. It then stitches the pairs together into longer sequences of points based on matching first/last elements, so that each sequence is one room in the 1D maze. A pairing between letters and points on the interior of these rooms (the warp points) is created and used to translate the lists of numbers into a string, which is the output.

The 2D maze is read from STDIN and the 1D maze is printed to STDOUT.

Haskell - 481 bytes

import Data.List
import Data.Char
e=elemIndices
o(x:p)q
 |x==last q=[q++p]
 |1>0=[]
b a=(([id,reverse]<*>[a]>>=).)
c!(x:y:z)=last$(y:c)!(x:z):((!)[].(:c++z)<$>(b x)(b y)o)
c!(x:[])=x:[]!c
c!z=z
main=interact(\m->let{n:_=e '\n'm;
g=e ' 'm;
j k=[k+d|d<-[1,n+1,-1,-n-1],elem(k+d)g];
k#x
 |d:[]<-j k\\[x]=d#k
 |1>0=k;
u=[]!nub[sort[k,l]|k<-g,(length.j)k>2,l<-(#k)<$>j k];
v=zip(nub$u>>=init.tail)$[65..90]++[96..122]
}in '|':(u>>= \r->init(r>>= \s->maybe ' 'chr(lookup s v):" ")++"|"))

This gets the list of spaces that are in the maze (numbered by index in the string) and walks down the corridors from each junction to create a list of pairs of dead ends and junctions in the maze which are directly connected by corridors. It then stitches the pairs together into longer sequences of points based on matching first/last elements, so that each sequence is one room in the 1D maze. A pairing between letters and points on the interior of these rooms (the warp points) is created and used to translate the lists of numbers into a string, which is the output.

The 2D maze is read from STDIN and the 1D maze is printed to STDOUT.