[Question]
  [
Your task: given an integer `n`, generate an embedded hexagon pattern following the below rules, to the nth depth. 
An embedded hexagon has the basic shape of this: (`n=0`)
```
 __      
/  \
\__/
```
Embedded Hexagons `n=1` and `n=2`:
```
  ____    
 /  \ \
/\__/  \
\      /
 \____/
    ________    
   /  \ \   \
  /\__/  \   \
 /\      /    \
/  \____/      \
\              /
 \            /
  \          /
   \________/
```
The length of each side is 2 times the length of the same side in the previous depth times two. The top and bottom sides are 2 characters long when `n=0` and the rest start out as 1 character long. The non top-bottom side lengths should be `2^n` long ([OEIS: A000079](https://oeis.org/A000079/ "OEIS: A000079")) and the top and bottom sides should follow the rule `2^(n+1)` (same OEIS).
The current hexagons are 0-indexed, you may chose to use 1-indexed if you want.
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the shortest answer wins!
  
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), ~~40~~ 29 bytes
*11 bytes saved thanks to @Neil by changing the while loop to a for-loop amongst other tricks*
```
ＦＮ«ＡＸ²ιβ×__β↓↘β←↙β↑←×__β↖β→↗β
```
[Try it online!](https://tio.run/nexus/charcoal#@/9@z7L3e9YdWv1@z8L3e3Yc2nRu57lNh6fHx5/b9Kht8qO2GSB6wqO2mSB6IpAJk5sGIiY9apt@btP//8YA "Charcoal – TIO Nexus")
### Explanation (outdated)
This program starts with generating the largest hexagon, and then does the smaller ones one-by-one in a while loop (1-indexed). For reference, `α` is the input number, `β` is the variable that contains `2^(α-1)` and `ι` is the iterating variable in the loop.
```
Ｎα                        # Take input and store in α
Ｗα«                       # While α do:
 ×_Ｘ²ι                    #  Write "_"*(2**ι); this forms the top edge of the hexagon
 ↓                         #  Go down
 ＡＸ²⁻ι¹β                 #  Assign 2**(ι-1) to β
 ↘β←                       #  Write \ β times in a SE direction (top right edge) and then go left
 ↙β↑                       #  Write / β times in a SW direction (bottom right edge) and then go up
 ←×_Ｘ²ι                   #  Write the bottom edge
 ↖β→↗β                    #  Just like before, write the top and bottom left edges
 Ａ⁻α¹α                    #  Decrement α
                          # Now the pointer is at the top left corner of the hexagon,
                          # from where the other smaller hexagons will soon be generated
```
[Answer]
# [Haskell](https://www.haskell.org/), ~~230~~ ~~217~~ 207 bytes
EDIT:
* -13 bytes: @xnor saw that my `#` could be just `max`.
* -10 bytes: And also that `zipWith` and `p` could be merged into a `?` operator, and that I'd (somehow!) reimplemented `replicate`.
`m` takes an `Integer` and returns a `String`.
```
m n=unlines.foldr1 o$((2^n)&).(2^)<$>[0..n]
l&t|a<-c[l,2*t]" _",b<-[c[l-i,1,2*t+2*i-2,1,l-i]" / \\ "|i<-[1..t]]=a:b++r(r<$>o[a]b)
c=(concat.).z replicate
o=max?' '?""
f?e=z f.(++repeat e)
r=reverse
z=zipWith
```
[Try it online!](https://tio.run/nexus/haskell#FYzRboQgFETf@QpCzC6selvtWyP1M/rg0gbZa3oTBMPSpjH775Y@zczJzKyWgqaQMVmXqxUS2tux8qC/g6eAd1iiv6WOx0rK/iOok4KiaqjepmeAYJg/5YcdWjf5pr9kI/inaOahnQpoqen@Yd1fqO2LL6QUnvj1ysWDSqkDyMZo@zrXdZKpvMbJmlkxp6WLwdkMCnaecPNUArKoV/s7nvl5FIItI@qdLyDLGDe0maNiSSf8wXRHtuudtnfKX8fx8gc "Haskell – TIO Nexus")
# How it works
* `m` is the main function. It uses `&` to generate the hexagons with proper padding, then folds them together with `o`.
* `l&t` generates a small hexagon of side length `t`, padded inside a large one of side length `l`, as a list of `String` lines.
	+ `a` is the top line of the hexagon, with the underscores.
	+ `b` is a list of the other lines in the upper half of the hexagon. The lines of `b` are centered in the padding, which is rectangular; this allows the next step to work.
	+ The bottom half of the hexagon is `a` overlaid on top of `b` with `o`, then reversed (both order of lines and within each line).
* `c` takes two arguments, a list of lengths and a string, and generates a string that has as many copies of each character in the original as the corresponding length, e.g. `c[1,3,2]"abc" == "abbbcc"`. It is used in `&` to generate the lines.
* `o` takes two arguments representing pictures as lists of lines, and overlays the first, smaller one on top of the second one.
	+ It is used both to combine hexagons and to add the bottom to each hexagon.
	+ It essentially works by using `?` twice to pad the first picture with infinitely many spaces both downwards and rightwards, then zipping together corresponding characters with `max`, which selects the non-space character if there is one.
* `(f?e)l m` pads a list `l` by appending infinitely many 'e' elements, then zips the resulting list and the list `m` with the `f` function.
[Answer]
## JavaScript (ES6), 258 bytes
```
f=(n,s=` `.repeat(1<<n),p=(n?f(n-1):`
`).replace(/(.*)\n/g,s+`$1 `+s)+s,t=`_`.repeat(2<<n))=>(s+t+s+`
`+s.replace(/ /g,"$'/$'$'  $`$`$`$`\\$'\n")).replace(/ /g,(c,i)=>p[i+(1<<n>>1)])+s.replace(/ /g,"$`\\$`$`  $'$'$'$'/$`\n").replace(/ +\/( *)\n$/,t+`/$1
`)
```
```
<input type=number min=0 oninput=o.textContent=f(+this.value)><pre id=o>
```
Explanation: For hexagons after the first, the previous hexagon is first generated and padded on each side (this relies on the output being a rectangle). (For the first heading, some dummy padding is created.) The top and top sides of the hexagon are generated, and all the spaces merged with the previous hexagon. (There's some trickery in order to get the hexagons to line up; this would be easier if extra margins were allowed.) The bottom sides of the hexagon are generated analogously to the top sides, and the bottom of the hexagon is then filled in. Care has to be taken to return rectangular output, including a trailing newline, for the recursion to work.
[Answer]
# PHP, 337 Bytes
0 Indexing
```
$h=array_fill(0,1+2*$v=2**($c=$argn),str_pad("",4*$v));for(;1+$c;$c--)for($i=0;$i<$e=2**$c*2+1;$i++){$z=$e-$i<2;$y=$i&&$i<$e/2;$x=$i>=$e/2&$i<$e-1;$h[$i]=substr_replace($h[$i],$s=str_pad(!$y?$z|$x?"\\":"":"/",$e-1+$z-$y+$y*$i*2-$x+$x*2*($e-$i),$z|!$i?"_":" ").(!$y?$z|$x?"/":"":"\\"),$v-$z-$y*$i-$x*($e-$i),strlen($s));}echo join("\n",$h);
```
[Try it online!](https://tio.run/nexus/php#TZBNboMwEIXX4RSJNYr8g0tA7SaOy0GaKnJdJ7hCBJk2AtqcnY5Blbqy35s334x9KNuqnc7X4IytaDDNxdFd@sRMByZcGvadJFBpE4IZTmdf11jMRcHhpgvOKVi9xNLuM5xa804JSR@xyphKEEpVLsAqsFKyWYPXOwX@AC72g@WFyFELgYNWMGpwEquFgkGD327nZIayR/ms433xZK4wX72Af9Xd11ucHlxbG@vo4qZY7vTfVskK4SU5HsmewlCSLJ79YhDCWBoDCBUwShgEDBw8LyT0Anpe4DvjWktq/NmAL8kJG9cEDfZAN8jeIDYSswjcL@CMxBa4yZmKSAT@Y@FytWsodPGz7omz1XX9cfUNJceGpFChO5so0VD3afoF "PHP – TIO Nexus")
Expanded
```
$h=array_fill(0,1+2*$v=2**($c=$argn),str_pad("",4*$v)); # fill array with maximal width
for(;1+$c;$c--)  # greatest hexagon to lowest
for($i=0;$i<$e=2**$c*2+1;$i++){ # loop through the rows
    $z=$e-$i<2;$y=$i&&$i<$e/2;$x=$i>=$e/2&$i<$e-1; # booleans last first ad second half
    $h[$i]=substr_replace($h[$i], # replace substring
    $s=str_pad(
        $z?"\\":($y?"/":($x?"\\":"")),
        $e-1+$z-$y+$y*$i*2-$x+$x*2*($e-$i),
        $z|!$i?"_":" "
        ).(!$z?!$y?$x?"/":"":"\\":"/"), # with string for smaller hexagon
    $v-$z-$y*$i-$x*($e-$i), # at offset
    strlen($s));
}
echo join("\n",$h); # Output
```
]