This sounds good to me.
Your code seems wrong.

// reading tarReader bytes using a io.pipe from file
func doesNotWork() error {
 	pr, pw := io.Pipe()
 	errC := make(chan error, 1)
 	go func() {
-		defer func() { _ = pw.Close() }()
 		errC <- readTar(DummyTar, pw)
 	}()

 	tarR := tar.NewReader(pr)
 	bArray := make([]byte, 1)
 	for {
 		_, err := tarR.Read(bArray)
 		if err == io.EOF {
 			fmt.Println("EOF reached!")
 			break
 		} else if err != nil {
 			return err
 		}
 	}
+	pw.Close()
 	<-errC
 	fmt.Println("doesNotWork finished successfully")
 	return nil
 }

This works.

As far I can tell, reading the file from tarR doesn't fully exhaust the underlying reader which is happening because (*tar.Reader).Read send io.EOF based on the tar metadata length, not the underlying reader sending EOF.
First copying the data into a buffer would have the same effect.
Calling tarR.Next() also fix it by exhausting the underlying reader.

Could also be that some padding data is left in the underlying reader and that tarR.Next() flush them out, but my memory of the tar format is unclear and I don't really remember trailing padding bytes.

@Jorropo Thanks for your help with this! You're right, I found 512 bytes in the pipe reader that needed to be drained after the tar io.EOF was reached. You can use pr.Read() or tarR.Next() after the tar io.EOF to fully flush the pipe and then the io.copy will close as expected.

It is still is a little odd to me that tarR.Read() will not flush the underline reader anymore after EOF but tarR.Next() will. I can add another tarR.Next() in my code after fully reading the tar to fix this but it seems a little confusing. I wonder if there is any merit to auto draining the underline reader when tar.Reader hits the io.EOF header.

This is an incorrect use of archive/tar.Reader
Next() has to be called to read any part, including the first. It's expected to be called until it reaches io.EOF
This is less obvious in your example because it uses 0 sized files as input.

Closing as not a bug

For anyone that may come across this issue. I still see this issue rarely with some tar files (will try to upload an example) while explicitly using tar.Next() until it reaches io.EOF. The only work around I have found is to drain the pipe reader manually after. tar.Next() will just keep returning io.EOF even if there are bytes still in the pipe.