Fix wrong Python executable path on Linux/macOS after creating conda environments (#1459)

Part of
#1454

## Bug

In `createNamedCondaEnvironment` and `createPrefixCondaEnvironment`, the
Python executable path is computed as:

```ts
const bin = os.platform() === 'win32' ? 'python.exe' : 'python';
// Then: path.join(envPath, bin)
```

On Linux/macOS, this produces `/path/to/env/python`, but conda installs
the Python executable at `/path/to/env/bin/python`.

## Why it's a bug

The environment appears in the VS Code picker and can be selected.
However, the internal `execInfo.run.executable` points to a non-existent
path. Any operation that invokes Python — running scripts, linting,
getting version info — fails silently. Users see a valid-looking conda
environment that they can select, but nothing works after selecting it.

The `quickCreateConda` function (line 1225) already had the correct
path:
```ts
os.platform() === 'win32' ? path.join(prefix, 'python.exe') : path.join(prefix, 'bin', 'python')
```

## Repro steps

1. On Linux or macOS, create a conda environment through the VS Code UI
(either named or prefix type).
2. The environment appears in the picker — select it.
3. Try running a Python script or checking the Python version.
4. Operations fail because the executable path `/path/to/env/python`
does not exist.

## Fix

Changed both `createNamedCondaEnvironment` (line 1085) and
`createPrefixCondaEnvironment` (line 1169) to use:

```ts
const bin = os.platform() === 'win32' ? 'python.exe' : path.join('bin', 'python');
```

This matches the correct pattern already used in `quickCreateConda`.

## Tests added

- `condaUtils.pythonExePath.unit.test.ts`: 3 test cases verifying
correct executable paths for both platform types and both environment
types.

Author: StellaHuang95

src/managers/conda/condaUtils.ts

@@ -1082,7 +1082,7 @@ export async function createNamedCondaEnvironment(
         },
         async () => {
             try {
-                const bin = os.platform() === 'win32' ? 'python.exe' : 'python';
+                const bin = os.platform() === 'win32' ? 'python.exe' : path.join('bin', 'python');
                 const output = await runCondaExecutable(runArgs);
                 log.info(output);
 
@@ -1166,7 +1166,7 @@ export async function createPrefixCondaEnvironment(
             },
             async () => {
                 try {
-                    const bin = os.platform() === 'win32' ? 'python.exe' : 'python';
+                    const bin = os.platform() === 'win32' ? 'python.exe' : path.join('bin', 'python');
                     const output = await runCondaExecutable(runArgs);
                     log.info(output);
                     const version = await getVersion(prefix);

src/test/managers/conda/condaUtils.pythonExePath.unit.test.ts

@@ -0,0 +1,67 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import assert from 'assert';
+import * as path from 'path';
+import * as sinon from 'sinon';
+import { EnvironmentManager } from '../../../api';
+import { CondaEnvManager } from '../../../managers/conda/condaEnvManager';
+import { getNamedCondaPythonInfo, getPrefixesCondaPythonInfo } from '../../../managers/conda/condaUtils';
+import { NativePythonFinder } from '../../../managers/common/nativePythonFinder';
+import * as platformUtils from '../../../common/utils/platformUtils';
+
+suite('Conda Python executable path construction', () => {
+    let isWindowsStub: sinon.SinonStub;
+    let mockManager: EnvironmentManager;
+
+    setup(() => {
+        mockManager = new CondaEnvManager(
+            {} as NativePythonFinder,
+            {} as any,
+            { info: sinon.stub(), error: sinon.stub(), warn: sinon.stub() } as any,
+        );
+    });
+
+    teardown(() => {
+        sinon.restore();
+    });
+
+    test('getNamedCondaPythonInfo: executable path uses bin/python on non-Windows', async () => {
+        isWindowsStub = sinon.stub(platformUtils, 'isWindows').returns(false);
+        const prefix = '/home/user/miniconda3/envs/myenv';
+        const executable = path.posix.join(prefix, 'bin', 'python');
+        const info = await getNamedCondaPythonInfo('myenv', prefix, executable, '3.12.0', '/usr/bin/conda', mockManager);
+
+        assert.ok(
+            info.execInfo.run.executable.includes(path.join('bin', 'python')) ||
+                info.execInfo.run.executable.endsWith('python'),
+            `executable should contain bin/python, got: ${info.execInfo.run.executable}`,
+        );
+        isWindowsStub.restore();
+    });
+
+    test('getPrefixesCondaPythonInfo: executable path uses bin/python on non-Windows', async () => {
+        isWindowsStub = sinon.stub(platformUtils, 'isWindows').returns(false);
+        const prefix = '/home/user/projects/.conda';
+        const executable = path.posix.join(prefix, 'bin', 'python');
+        const info = await getPrefixesCondaPythonInfo(prefix, executable, '3.12.0', '/usr/bin/conda', mockManager);
+
+        assert.ok(
+            info.execInfo.run.executable.includes(path.join('bin', 'python')) ||
+                info.execInfo.run.executable.endsWith('python'),
+            `executable should contain bin/python, got: ${info.execInfo.run.executable}`,
+        );
+        isWindowsStub.restore();
+    });
+
+    test('getNamedCondaPythonInfo: executable path uses python.exe on Windows', async () => {
+        isWindowsStub = sinon.stub(platformUtils, 'isWindows').returns(true);
+        const prefix = 'C:\\Users\\user\\miniconda3\\envs\\myenv';
+        const executable = path.win32.join(prefix, 'python.exe');
+        const info = await getNamedCondaPythonInfo('myenv', prefix, executable, '3.12.0', 'C:\\conda\\conda.exe', mockManager);
+
+        assert.ok(
+            info.execInfo.run.executable.endsWith('python.exe'),
+            `executable should end with python.exe, got: ${info.execInfo.run.executable}`,
+        );
+        isWindowsStub.restore();
+    });
+});