05AB1E, 21 bytes

Defines a program $f : colorpurpletextttAlphabeticChar rightarrow colorpurpletextttString$

Code:

2AA¹k._•1못*Ć,ãiDΣ•Λ

Try it online!

Breakdown:

2AA¹k._•1못*Ć,ãiDΣ•Λ

2 # <length>
 AA¹k._ # <filler>
 •1못*Ć,ãiDΣ• # <pattern>
 Λ # Invoke the canvas function.

Explanation:

The canvas (Λ) in this particular context works as a function with the following signature:

$$
mathsfLambda : left(textttlength: colorpurpletextttNat, textttfiller: colorpurpletextttString, textttpattern: colorpurpletextttNatright) rightarrow colorpurpletextttString
$$

The $textttpattern$ parameter is in this situation a number defining the directions. In the code, this number is represented as •1못*Ć,ãiDΣ•, which is a compressed version of the big number $2232344565666667670012122$. Directions are denoted in the following manner:

$$
beginarrayl
7 & & 0 & & 1 \
& nwarrow & uparrow & nearrow & \
6 & leftarrow & bullet & rightarrow & 2 \
& swarrow & downarrow & searrow & \
5 & & 4 & & 3
endarray
$$

This means that the big number represents the following pattern of directions:

$$
[rightarrow, rightarrow, searrow, rightarrow, searrow, downarrow, downarrow, swarrow, leftarrow, swarrow, leftarrow, leftarrow, leftarrow, leftarrow, leftarrow, nwarrow, leftarrow, nwarrow, uparrow, uparrow, nearrow, rightarrow, nearrow, rightarrow, rightarrow]
$$

With this signature context, the canvas iterates through the $textttpattern$ list and writes $textttlength$ characters from the $textttfiller$ in the current direction.

The $textttlength$ is specified in the code as $2$ (at the beginning of the code). For the $textttfiller$, we need a rotated version of the alphabet such that it starts with the given input. That is done with the following code (try it here):

AA¹k._

 A¹k # Find the <index> of the given input character in the alphabet
A ._ # Rotate the alphabet to the left <index> times.

In pseudocode, this would be executed by the canvas function:

$
beginarrayl
1. & textWrite colorbluetextttab text in the direction rightarrow \
2. & textWrite colorbluetextttbc text in the direction rightarrow \
3. & textWrite colorbluetextttcd text in the direction searrow \
4. & textWrite colorbluetextttde text in the direction rightarrow \
5. & textWrite colorbluetextttef text in the direction searrow \
6. & textWrite colorbluetextttfg text in the direction downarrow \
dots
endarray
$

Lastly, you can see that the filler argument is 'rotated' $textttlength - 1$ times to the right, meaning that the canvas would iterate through the following (cycled and therefore infinite) list:

$$
[colorbluetextttab, colorbluetextttbc, colorbluetextttcd, colorbluetextttde, colorbluetextttef, colorbluetextttfg, colorbluetextttgh, colorbluetexttthi, colorbluetextttij, colorbluetextttjk, ...
$$

Which results in the desired alphabet soup ascii-art shape.

Perl 6, 100 bytes

"2XYZABC
 VW5DE
U9F
T9G
S9H
 RQ5JI
2PONMLK".trans(/S/=>(try ' 'x$/+1))

Try it online!

Replaces all letters in the string with their shifted counterparts, while replacing digits with the number of spaces they represent plus one.

Explanation

 # Anonymous code block
 "...".trans(/S/=> ) # Translate non-whitespace
 (try ' 'x$/+1) # If digits, the amount of spaces plus one
 ||chr ($/.ord+.ord)%26+64 # Else the shifted letter

Ruby, 107 bytes

->na=(0..6).map' '*11
(?A..?Z).mapi
a*$/

Try it online!

Improved syntax "i".to_c -> 1i (Suggested by Jordan)

Changed coordinate system so 0 degrees is at right instead of top. This enables 0.5 -> 6

Adjusted multipliers of j and k for shortness

Rather than print output puts a, concatenate array elements and return a string a*$/

Ruby, 119 bytes

->na=(0..6).map' '*11
(?A..?Z).map
puts a

Uses a complex number raised to a power to map to an ellipse. A complete turn is 26, so each quadrant is 6.5.

This approach relies on the required output resembling an ellipse sufficiently that a valid mapping can be achieved.

Try it online!

MATL, 49 bytes

7I8*32tvB[1b]&Zvc2Y2j7+_YSy&f7-w4-_Z;YPE,&S])yg(

What a mess. But it was fun writing. There's even an arctangent involved.

Try it online!

Charcoal, 33 bytes

ＧＨ→→↘→↘↓↓77←←←←↖←↖↑↑↗→↗→→²✂⁺αα⌕αＳ

Try it online! Link is to verbose version of code. Explanation:

ＧＨ

Trace a path.

→→↘→↘↓↓77←←←←↖←↖↑↑↗→↗→→

Outline the bowl. Each 7 expands to ↙←.

²

Move one character at a time (this API overlaps each line's ends with the next).

✂⁺αα⌕αＳ

Draw using the doubled alphabet, but starting at the position of the input character.

JavaScript (Node.js),  121  119 bytes

Saved 2 bytes thanks to @tsh

c=>`2XYZABC
0VW5DE
U9F
T9G
S9H
0RQ5JI
2PONMLK`.replace(/./g,x=>''.padEnd(+x+1)||(B=Buffer)([65+([a,b]=B(c+x),a+b)%26]))

Try it online!

How?

This code abuses Buffer to extract the ASCII codes of the template letter $x$ and input letter $c$ and convert them back into the target letter.

Example with $c=$"H" and $x=$"B"

// extracting the ASCII codes
Buffer(c + x) → Buffer("HB") → <Buffer 48 42>

// assigning them to variables
[a, b] = Buffer(c + x) → a = 0x48 (72) and b = 0x42 (66)

// computing the ASCII code of the target letter
65 + ((a + b) % 26) → 65 + (138 % 26) → 65 + 8 → 73

// turning it back into a character
Buffer([73]) → <Buffer 49> → implicitly coerced to "I" by replace()

R, 139 122 bytes

-17 bytes thanks to Giuseppe

u=utf8ToInt;`*`=rep;o=c(' '*12,'
')*7;o[u(" &3@LKWVUTSRDC5(")]=LETTERS[(13:38+u(scan(,'')))%%26+1];cat(o,sep='')

Explanation:

o=rep(c(rep(' ',12),'
'),7) 

Builds an empty box of spaces

u(" &3@LKWVUTSRDC5(")

is a set of indices for letter positions corresponding to:

c(7:9,23,24,38,51,64,76,75,87:82,68,67,53,40,27,15,16,4:6)

TIO

Python 2, 129 bytes

lambda x:''.join((i,chr((ord(x)+ord(i))%26+65),' '*5)[ord(i)/46]for i in''' XYZABC
 VW] DE
U]]F
T]]G
S]]H
 RQ] JI
 PONMLK''')

Try it online!

R, 218 197 bytes

-21 bytes thanks to Giuseppe

function(t,l=letters,`*`=rep,s=" ",n="
",`~`=`[`,r=c(l~l>=t,l))cat(s*3,r~24:26,r~1:3,n,s,r~22:23,q<-s*6,r~4:5,n,r~21,u<-s*10,r~6,n,r~20,u,r~7,n,r~19,u,r~8,n,s,r~17:18,q,r~10:9,n,s*3,r~16:11,sep='')

Try it online!

Ungolfed:

alphasoup <- function(startlet)
 startnum <- which(l == startlet)
 rotatedletters <- c(letters[startnum:26], letters[1:(startnum -1)])[1:26]
 cat(' ',rotatedletters[24:26],rotatedletters[1:3], 'n ', 
 rotatedletters[22:23], s6 <- ' ', rotatedletters[4:5], 'n',
 rotatedletters[21], s10 <- rep(' ', 10), rotatedletters[6], 'n',
 rotatedletters[20], s10, rotatedletters[7], 'n',
 rotatedletters[19], s10, rotatedletters[8], 'n ',
 rotatedletters[17:18], s6, rotatedletters[10:9], 'n ',
 rotatedletters[16:11],
 sep = '')

Created rotated letter vector and uses cat to fill out rim of bowl with that vector.

Wolfram Language (Mathematica), 258 bytes

(t[x_]:=Table[" ",x];w=RotateRight[Alphabet[],4-LetterNumber@#];j=Join;a[x_,y_]:=j[w[[x]],t@10,w[[y]]];b[m_,n_]:=j[t@1,w[[m;;m+1]],t@6,w[[n;;n+1]],t@1];""<>#&/@j[t@3,w[[1;;6]]],b[25,7],a[24,9],a[23,10],a[22,11],Reverse@b[12,20],j[t@3,w[[19;;14;;-1]]])&

Try it online!

APL+WIN, 72 bytes

Prompts for character

m←7 12⍴' '⋄n←(7⍴2)⊤v,⌽v←(⍳3)/28 34 65⋄((,n)/,m)←(22+s⍳⎕)⌽s←⎕av[65+⍳26]⋄m

Try it online!Coutesy of Dyalog Classic

Red, 139 bytes

func[a][foreach c XYZABC
 VW DE
U F
T G
S H
 RQ JI
 PONMLK[if c > sp[c: c + a % 26 + 65]prin c]]

Try it online!

A really naive solution.

TSQL query, 240 bytes

DECLARE @y char='G'

,@ char(91)='';WITH C as(SELECT 7a,'5585877636333330301122555'z,ascii(@y)x
UNION ALL
SELECT a+left(z,1)/3*13+left(z,1)%3-14,stuff(z,1,1,''),(x+14)%26+65FROM
C WHERE''<z)SELECT
@=stuff(stuff(@,a,1,char(x)),1+a/13*13,1,char(13))FROM
C PRINT @

The output starts with a blank line.

The long list of numbers represents directions.

I would have made a try it out link, but the site was messing up the output. Hopefully some nice person, will verify that this works in SQL Server Management Studio.

Perl 5 -p, 110 bytes

$b=/A/?Z:chr(-1+ord);$_=eval("'2XYZABC
 VW5DE
U9F
T9G
S9H
 RQ5JI
2PONMLK'=~y/A-Z/$_-ZA-$b/r");s/d/$".$"x$&/eg

Try it online!

Kotlin, 148 bytes

l:Char->"""2XYZABC
 VW5DE
U9F
T9G
S9H
 RQ5JI
2PONMLK""".mapc->if(c>'@')(((c-'A')+(l-'A'))%26+65).toChar()
else if(c>' ')" ".repeat(c-'/')
else c

Try it online!

Haskell, 127 bytes

("cXYZABC aVWfDE UjF TjG SjH aRQfJI cPONMLK">>=).(?)
t?c|c>'Z'=' '<$['a'..c]|c<'!'="n"|t<'B'=[c]|c>'Y'=t?'@'|1<2=pred t?succ c

Try it online!

Each character in the encoded string is decoded by function ? into a string:

t?c -- 't' is the starting char,
 -- 'c' the char from the encoded string
 |c>'Z'=' '<$['a'..c] -- if 'c' is a lowercase letter, return some spaces
 -- 'a': one, 'b': two, etc
 |c<'!'="n" -- if 'c' is a space, return a newline
 |t<'B'=[c] -- if 't' is the letter A, return 'c'
 |c>'Y'=t?'@' -- wrap around Z
 |1<2=pred t?succ c -- else the result is the same as starting one letter
 -- earlier (pred t) but looking at the successor of 'c'