chore(lambda): handle Runtime.ALL correctly in LayerVersion compatibleRuntimes (#35351)

### Issue # (if applicable)

Closes #35348.

### Reason for this change

`Runtime.ALL` contains 43+ runtime entries (including deprecated ones), but AWS Lambda limits `compatibleRuntimes` to maximum 15 entries and only accepts currently supported runtimes. When users specify `compatibleRuntimes: Runtime.ALL` for Lambda layers, deployment fails with CloudFormation validation errors:
- "Member must have length less than or equal to 15"
- "Member must satisfy enum value set" for supported runtimes only

This breaks existing user code that relies on the documented `Runtime.ALL` constant for Lambda layers.

### Description of changes

Modified the LayerVersion constructor to detect when `compatibleRuntimes` is set to `Runtime.ALL` and treat it as `undefined`, allowing AWS to use its default "all supported runtimes" behavior:

- Added conditional logic in `CfnLayerVersion` resource creation to check for `Runtime.ALL` via reference equality
- When `Runtime.ALL` is detected, `compatibleRuntimes` is set to `undefined` in the CloudFormation template
- When `undefined`, AWS Lambda defaults to supporting all currently supported runtimes (the intended behavior)
- All other behavior remains unchanged - specific runtime arrays and `undefined` work as before
- Updated documentation to clarify that `Runtime.ALL` is equivalent to `undefined`

**Technical Implementation**:
```typescript
compatibleRuntimes: (props.compatibleRuntimes === Runtime.ALL)
  ? undefined
  : props.compatibleRuntimes?.map(r => r.name),
```

### Describe any new or updated permissions being added

N/A - No IAM permissions or resource access changes.

### Description of how you validated changes

- **Unit tests**: Added comprehensive test cases using `test.each` to verify that both `Runtime.ALL` and `undefined` result in omitting `CompatibleRuntimes` from the CloudFormation template. This eliminates code duplication and follows Jest best practices. All existing layer tests continue to pass (7/7).
- **Integration tests**: No additional integration tests required as this change leverages existing AWS Lambda service behavior when `CompatibleRuntimes` is omitted from the CloudFormation template. The AWS service automatically applies compatibility with all currently supported runtimes, which is the intended behavior for `Runtime.ALL`.

**Test Coverage**:
- ✅ `Runtime.ALL` produces `undefined` in CloudFormation template
- ✅ `undefined` compatibleRuntimes produces `undefined` in CloudFormation template  
- ✅ Specific runtime arrays work unchanged
- ✅ Empty runtime array validation still throws error
- ✅ All existing layer functionality preserved
- ✅ Refactored tests using `test.each` to eliminate duplication

### Checklist
- [x] My code adheres to the [CONTRIBUTING GUIDE](https://github.com/aws/aws-cdk/blob/main/CONTRIBUTING.md) and [DESIGN GUIDELINES](https://github.com/aws/aws-cdk/blob/main/docs/DESIGN_GUIDELINES.md)

----

*By submitting this pull request, I confirm that my contribution is made under the terms of the Apache-2.0 license*

Author: pahud

packages/aws-cdk-lib/aws-lambda/lib/layers.ts

@@ -79,7 +79,7 @@ export interface ILayerVersion extends IResource, ILayerVersionRef {
   /**
    * The runtimes compatible with this Layer.
    *
-   * @default Runtime.All
+   * @default - All supported runtimes. Setting this to Runtime.ALL is equivalent to leaving it undefined.
    */
   readonly compatibleRuntimes?: Runtime[];
 
@@ -219,7 +219,9 @@ export class LayerVersion extends LayerVersionBase {
     }
 
     const resource: CfnLayerVersion = new CfnLayerVersion(this, 'Resource', {
-      compatibleRuntimes: props.compatibleRuntimes && props.compatibleRuntimes.map(r => r.name),
+      compatibleRuntimes: (props.compatibleRuntimes === Runtime.ALL)
+        ? undefined
+        : props.compatibleRuntimes?.map(r => r.name),
       compatibleArchitectures: props.compatibleArchitectures?.map(a => a.name),
       content: {
         s3Bucket: code.s3Location.bucketName,

packages/aws-cdk-lib/aws-lambda/test/layers.test.ts

@@ -122,4 +122,34 @@ describe('layers', () => {
       CompatibleArchitectures: ['arm64'],
     });
   });
+
+  test.each([
+    ['Runtime.ALL is handled correctly', { compatibleRuntimes: lambda.Runtime.ALL }],
+    ['undefined compatibleRuntimes is handled correctly', {}],
+  ])('%s by omitting compatibleRuntimes', (_, props) => {
+    // GIVEN
+    const stack = new cdk.Stack();
+    const bucket = new s3.Bucket(stack, 'Bucket');
+    const code = new lambda.S3Code(bucket, 'ObjectKey');
+
+    // WHEN
+    new lambda.LayerVersion(stack, 'LayerVersion', {
+      code,
+      ...props,
+    });
+
+    // THEN - CompatibleRuntimes should be omitted from CloudFormation template
+    const template = Template.fromStack(stack);
+    template.hasResourceProperties('AWS::Lambda::LayerVersion', {
+      Content: {
+        S3Bucket: stack.resolve(bucket.bucketName),
+        S3Key: 'ObjectKey',
+      },
+    });
+
+    // Verify that CompatibleRuntimes is NOT present in the template
+    const resources = template.findResources('AWS::Lambda::LayerVersion');
+    const layerResource = Object.values(resources)[0];
+    expect(layerResource.Properties).not.toHaveProperty('CompatibleRuntimes');
+  });
 });