Remove layout.repr.align-packed

This more or less repeats what is already said in
layout.repr.alignment.intro where it explains that they are modifiers
that affect a representation.

Author: ehuss

src/type-layout.md

@@ -138,26 +138,8 @@ The *`repr` [attribute][attributes]* can change the representation and layout of
 > [!NOTE]
 > As a consequence of the representation being an attribute on the item, the representation does not depend on generic parameters. Any two types with the same name have the same representation. For example, `Foo<Bar>` and `Foo<Baz>` both have the same representation.
 
-r[layout.repr.align-packed]
-The alignment may be raised or lowered with the `align` and `packed` modifiers respectively. They alter the representation specified in the attribute. If no representation is specified, the default one is altered.
 
-```rust
-// Default representation, alignment lowered to 2.
-#[repr(packed(2))]
-struct PackedStruct {
-    first: i16,
-    second: i8,
-    third: i32
-}
 
-// C representation, alignment raised to 8
-#[repr(C, align(8))]
-struct AlignedStruct {
-    first: i16,
-    second: i8,
-    third: i32
-}
-```
 
 r[layout.repr.inter-field]
 The representation of a type can change the padding between fields, but does not change the layout of the fields themselves. For example, a struct with a `C` representation that contains a struct `Inner` with the `Rust` representation will not change the layout of `Inner`.
@@ -495,6 +477,25 @@ r[layout.repr.alignment]
 r[layout.repr.alignment.intro]
 The `align` and `packed` modifiers can be used to respectively raise or lower the alignment of `struct`s and `union`s. `packed` may also alter the padding between fields (although it will not alter the padding inside of any field). On their own, `align` and `packed` do not provide guarantees about the order of fields in the layout of a struct or the layout of an enum variant, although they may be combined with representations (such as `C`) which do provide such guarantees.
 
+> [!EXAMPLE]
+> ```rust
+> // Default representation, alignment lowered to 2.
+> #[repr(packed(2))]
+> struct PackedStruct {
+>     first: i16,
+>     second: i8,
+>     third: i32
+> }
+>
+> // C representation, alignment raised to 8
+> #[repr(C, align(8))]
+> struct AlignedStruct {
+>     first: i16,
+>     second: i8,
+>     third: i32
+> }
+> ```
+
 r[layout.repr.alignment.constraint-alignment]
 The alignment is specified as an integer parameter in the form of `#[repr(align(x))]` or `#[repr(packed(x))]`. The alignment value must be a power of two from 1 up to 2<sup>29</sup>. For `packed`, if no value is given, as in `#[repr(packed)]`, then the value is 1.